From 37e5e11c52112f7ef0304c0ba1d094ccb24a1bd4 Mon Sep 17 00:00:00 2001 From: DuckDB Labs GitHub Bot Date: Fri, 3 Jan 2025 00:33:56 +0000 Subject: [PATCH 01/16] Update vendored DuckDB sources to 85336acf --- .../core_functions/aggregate/holistic/mad.cpp | 8 +- .../scalar/array/array_functions.cpp | 11 +- .../core_functions/scalar/bit/bitstring.cpp | 15 +- .../core_functions/scalar/blob/base64.cpp | 4 +- .../core_functions/scalar/blob/encode.cpp | 4 +- .../core_functions/scalar/date/date_part.cpp | 24 +- .../core_functions/scalar/date/date_trunc.cpp | 3 + .../core_functions/scalar/date/make_date.cpp | 13 +- .../scalar/date/time_bucket.cpp | 3 + .../scalar/date/to_interval.cpp | 78 +- .../core_functions/scalar/generic/binning.cpp | 1 + .../scalar/list/array_slice.cpp | 2 +- .../scalar/list/list_aggregates.cpp | 2 + .../scalar/list/list_distance.cpp | 6 + .../core_functions/scalar/list/range.cpp | 6 + .../core_functions/scalar/map/map.cpp | 1 + .../scalar/map/map_from_entries.cpp | 1 + .../scalar/map/map_keys_values.cpp | 18 +- .../core_functions/scalar/math/numeric.cpp | 99 +- .../scalar/operators/bitwise.cpp | 18 + .../core_functions/scalar/random/setseed.cpp | 1 + .../core_functions/scalar/string/hex.cpp | 8 +- .../core_functions/scalar/string/pad.cpp | 12 +- .../core_functions/scalar/string/printf.cpp | 2 + .../core_functions/scalar/string/repeat.cpp | 3 + src/duckdb/extension/icu/icu-datepart.cpp | 3 + src/duckdb/extension/icu/icu-makedate.cpp | 16 +- src/duckdb/extension/icu/icu-timebucket.cpp | 3 + src/duckdb/extension/icu/icu-timezone.cpp | 3 + src/duckdb/src/common/enum_util.cpp | 9 +- .../expression_executor/execute_function.cpp | 1 + .../aggregate/physical_streaming_window.cpp | 2 +- .../scanner/string_value_scanner.cpp | 30 +- .../csv_scanner/sniffer/dialect_detection.cpp | 14 +- .../csv_scanner/sniffer/type_detection.cpp | 10 +- .../state_machine/csv_state_machine_cache.cpp | 35 +- .../table_function/csv_file_scanner.cpp | 3 +- .../aggregate/sorted_aggregate_function.cpp | 4 +- src/duckdb/src/function/function.cpp | 4 +- .../src/function/scalar/date/strftime.cpp | 2 + .../src/function/scalar/generic/error.cpp | 1 + .../src/function/scalar/list/list_extract.cpp | 3 +- .../src/function/scalar/list/list_resize.cpp | 4 +- .../function/scalar/operator/arithmetic.cpp | 193 +- .../src/function/scalar/sequence/nextval.cpp | 2 + .../src/function/scalar/string/length.cpp | 3 + .../src/function/scalar/string/regexp.cpp | 3 + src/duckdb/src/function/table/read_csv.cpp | 45 +- .../function/table/version/pragma_version.cpp | 6 +- .../function/window/window_value_function.cpp | 170 +- .../duckdb/common/enums/function_errors.hpp | 2 +- .../src/include/duckdb/common/platform.hpp | 33 +- .../vector_operations/unary_executor.hpp | 4 +- .../operator/csv_scanner/base_scanner.hpp | 16 +- .../operator/csv_scanner/csv_state.hpp | 3 +- .../csv_scanner/csv_state_machine.hpp | 4 +- .../csv_scanner/csv_state_machine_cache.hpp | 2 +- .../csv_scanner/string_value_scanner.hpp | 2 +- .../src/include/duckdb/function/function.hpp | 12 +- .../function/window/window_value_function.hpp | 2 + .../main/relation/write_parquet_relation.hpp | 2 +- .../src/include/duckdb/main/settings.hpp | 6 +- .../expression/bound_function_expression.hpp | 1 + .../src/main/relation/read_csv_relation.cpp | 81 +- .../optimizer/join_order/relation_manager.cpp | 8 + .../expression/transform_function.cpp | 2 +- .../planner/binder/statement/bind_create.cpp | 236 - .../binder/statement/bind_create_table.cpp | 269 +- .../expression/bound_function_expression.cpp | 7 + .../storage/compression/roaring/common.cpp | 6 +- src/duckdb/third_party/fsst/libfsst.hpp | 1 + .../libpg_query/src_backend_parser_gram.cpp | 24432 ++++++++-------- 72 files changed, 13301 insertions(+), 12742 deletions(-) diff --git a/src/duckdb/extension/core_functions/aggregate/holistic/mad.cpp b/src/duckdb/extension/core_functions/aggregate/holistic/mad.cpp index 2319184e9..dedb74297 100644 --- a/src/duckdb/extension/core_functions/aggregate/holistic/mad.cpp +++ b/src/duckdb/extension/core_functions/aggregate/holistic/mad.cpp @@ -276,7 +276,7 @@ AggregateFunction GetTypedMedianAbsoluteDeviationAggregateFunction(const Logical return fun; } -AggregateFunction GetMedianAbsoluteDeviationAggregateFunction(const LogicalType &type) { +AggregateFunction GetMedianAbsoluteDeviationAggregateFunctionInternal(const LogicalType &type) { switch (type.id()) { case LogicalTypeId::FLOAT: return GetTypedMedianAbsoluteDeviationAggregateFunction(type, type); @@ -314,6 +314,12 @@ AggregateFunction GetMedianAbsoluteDeviationAggregateFunction(const LogicalType } } +AggregateFunction GetMedianAbsoluteDeviationAggregateFunction(const LogicalType &type) { + auto result = GetMedianAbsoluteDeviationAggregateFunctionInternal(type); + result.errors = FunctionErrors::CAN_THROW_RUNTIME_ERROR; + return result; +} + unique_ptr BindMedianAbsoluteDeviationDecimal(ClientContext &context, AggregateFunction &function, vector> &arguments) { function = GetMedianAbsoluteDeviationAggregateFunction(arguments[0]->return_type); diff --git a/src/duckdb/extension/core_functions/scalar/array/array_functions.cpp b/src/duckdb/extension/core_functions/scalar/array/array_functions.cpp index e685d41f9..af7d0ee03 100644 --- a/src/duckdb/extension/core_functions/scalar/array/array_functions.cpp +++ b/src/duckdb/extension/core_functions/scalar/array/array_functions.cpp @@ -210,9 +210,13 @@ template static void AddArrayFoldFunction(ScalarFunctionSet &set, const LogicalType &type) { const auto array = LogicalType::ARRAY(type, optional_idx()); if (type.id() == LogicalTypeId::FLOAT) { - set.AddFunction(ScalarFunction({array, array}, type, ArrayGenericFold, ArrayGenericBinaryBind)); + ScalarFunction function({array, array}, type, ArrayGenericFold, ArrayGenericBinaryBind); + BaseScalarFunction::SetReturnsError(function); + set.AddFunction(function); } else if (type.id() == LogicalTypeId::DOUBLE) { - set.AddFunction(ScalarFunction({array, array}, type, ArrayGenericFold, ArrayGenericBinaryBind)); + ScalarFunction function({array, array}, type, ArrayGenericFold, ArrayGenericBinaryBind); + BaseScalarFunction::SetReturnsError(function); + set.AddFunction(function); } else { throw NotImplementedException("Array function not implemented for type %s", type.ToString()); } @@ -267,6 +271,9 @@ ScalarFunctionSet ArrayCrossProductFun::GetFunctions() { ScalarFunction({float_array, float_array}, float_array, ArrayFixedCombine)); set.AddFunction( ScalarFunction({double_array, double_array}, double_array, ArrayFixedCombine)); + for (auto &func : set.functions) { + BaseScalarFunction::SetReturnsError(func); + } return set; } diff --git a/src/duckdb/extension/core_functions/scalar/bit/bitstring.cpp b/src/duckdb/extension/core_functions/scalar/bit/bitstring.cpp index 3dfb76a07..0dbcb8ebc 100644 --- a/src/duckdb/extension/core_functions/scalar/bit/bitstring.cpp +++ b/src/duckdb/extension/core_functions/scalar/bit/bitstring.cpp @@ -46,6 +46,9 @@ ScalarFunctionSet BitStringFun::GetFunctions() { ScalarFunction({LogicalType::VARCHAR, LogicalType::INTEGER}, LogicalType::BIT, BitStringFunction)); bitstring.AddFunction( ScalarFunction({LogicalType::BIT, LogicalType::INTEGER}, LogicalType::BIT, BitStringFunction)); + for (auto &func : bitstring.functions) { + BaseScalarFunction::SetReturnsError(func); + } return bitstring; } @@ -64,8 +67,10 @@ struct GetBitOperator { }; ScalarFunction GetBitFun::GetFunction() { - return ScalarFunction({LogicalType::BIT, LogicalType::INTEGER}, LogicalType::INTEGER, - ScalarFunction::BinaryFunction); + ScalarFunction func({LogicalType::BIT, LogicalType::INTEGER}, LogicalType::INTEGER, + ScalarFunction::BinaryFunction); + BaseScalarFunction::SetReturnsError(func); + return func; } //===--------------------------------------------------------------------===// @@ -90,8 +95,10 @@ static void SetBitOperation(DataChunk &args, ExpressionState &state, Vector &res } ScalarFunction SetBitFun::GetFunction() { - return ScalarFunction({LogicalType::BIT, LogicalType::INTEGER, LogicalType::INTEGER}, LogicalType::BIT, - SetBitOperation); + ScalarFunction function({LogicalType::BIT, LogicalType::INTEGER, LogicalType::INTEGER}, LogicalType::BIT, + SetBitOperation); + BaseScalarFunction::SetReturnsError(function); + return function; } //===--------------------------------------------------------------------===// diff --git a/src/duckdb/extension/core_functions/scalar/blob/base64.cpp b/src/duckdb/extension/core_functions/scalar/blob/base64.cpp index 6a6229275..fb903fa80 100644 --- a/src/duckdb/extension/core_functions/scalar/blob/base64.cpp +++ b/src/duckdb/extension/core_functions/scalar/blob/base64.cpp @@ -39,7 +39,9 @@ ScalarFunction ToBase64Fun::GetFunction() { } ScalarFunction FromBase64Fun::GetFunction() { - return ScalarFunction({LogicalType::VARCHAR}, LogicalType::BLOB, Base64DecodeFunction); + ScalarFunction function({LogicalType::VARCHAR}, LogicalType::BLOB, Base64DecodeFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } } // namespace duckdb diff --git a/src/duckdb/extension/core_functions/scalar/blob/encode.cpp b/src/duckdb/extension/core_functions/scalar/blob/encode.cpp index 7fb4b436f..66cedb0b5 100644 --- a/src/duckdb/extension/core_functions/scalar/blob/encode.cpp +++ b/src/duckdb/extension/core_functions/scalar/blob/encode.cpp @@ -34,7 +34,9 @@ ScalarFunction EncodeFun::GetFunction() { } ScalarFunction DecodeFun::GetFunction() { - return ScalarFunction({LogicalType::BLOB}, LogicalType::VARCHAR, DecodeFunction); + ScalarFunction function({LogicalType::BLOB}, LogicalType::VARCHAR, DecodeFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } } // namespace duckdb diff --git a/src/duckdb/extension/core_functions/scalar/date/date_part.cpp b/src/duckdb/extension/core_functions/scalar/date/date_part.cpp index 79d09226d..1aeb4550c 100644 --- a/src/duckdb/extension/core_functions/scalar/date/date_part.cpp +++ b/src/duckdb/extension/core_functions/scalar/date/date_part.cpp @@ -1705,6 +1705,9 @@ ScalarFunctionSet GetGenericDatePartFunction(scalar_function_t date_func, scalar operator_set.AddFunction(ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::BIGINT, std::move(ts_func), nullptr, nullptr, ts_stats, DATE_CACHE)); operator_set.AddFunction(ScalarFunction({LogicalType::INTERVAL}, LogicalType::BIGINT, std::move(interval_func))); + for (auto &func : operator_set.functions) { + BaseScalarFunction::SetReturnsError(func); + } return operator_set; } @@ -2019,7 +2022,11 @@ ScalarFunctionSet QuarterFun::GetFunctions() { } ScalarFunctionSet DayOfWeekFun::GetFunctions() { - return GetDatePartFunction(); + auto set = GetDatePartFunction(); + for (auto &func : set.functions) { + BaseScalarFunction::SetReturnsError(func); + } + return set; } ScalarFunctionSet ISODayOfWeekFun::GetFunctions() { @@ -2046,9 +2053,14 @@ ScalarFunctionSet TimezoneFun::GetFunctions() { auto operator_set = GetDatePartFunction(); // PG also defines timezone(INTERVAL, TIME_TZ) => TIME_TZ - operator_set.AddFunction( - ScalarFunction({LogicalType::INTERVAL, LogicalType::TIME_TZ}, LogicalType::TIME_TZ, - DatePart::TimezoneOperator::BinaryFunction)); + ScalarFunction function({LogicalType::INTERVAL, LogicalType::TIME_TZ}, LogicalType::TIME_TZ, + DatePart::TimezoneOperator::BinaryFunction); + + operator_set.AddFunction(function); + + for (auto &func : operator_set.functions) { + BaseScalarFunction::SetReturnsError(func); + } return operator_set; } @@ -2241,6 +2253,10 @@ ScalarFunctionSet DatePartFun::GetFunctions() { date_part.AddFunction(StructDatePart::GetFunction(LogicalType::INTERVAL)); date_part.AddFunction(StructDatePart::GetFunction(LogicalType::TIME_TZ)); + for (auto &func : date_part.functions) { + BaseScalarFunction::SetReturnsError(func); + } + return date_part; } 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 b82792760..cb54e30de 100644 --- a/src/duckdb/extension/core_functions/scalar/date/date_trunc.cpp +++ b/src/duckdb/extension/core_functions/scalar/date/date_trunc.cpp @@ -728,6 +728,9 @@ ScalarFunctionSet DateTruncFun::GetFunctions() { DateTruncFunction, DateTruncBind)); date_trunc.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::INTERVAL}, LogicalType::INTERVAL, DateTruncFunction)); + for (auto &func : date_trunc.functions) { + BaseScalarFunction::SetReturnsError(func); + } return date_trunc; } diff --git a/src/duckdb/extension/core_functions/scalar/date/make_date.cpp b/src/duckdb/extension/core_functions/scalar/date/make_date.cpp index 3a526a1ef..71591a227 100644 --- a/src/duckdb/extension/core_functions/scalar/date/make_date.cpp +++ b/src/duckdb/extension/core_functions/scalar/date/make_date.cpp @@ -140,12 +140,17 @@ ScalarFunctionSet MakeDateFun::GetFunctions() { {"year", LogicalType::BIGINT}, {"month", LogicalType::BIGINT}, {"day", LogicalType::BIGINT}}; make_date.AddFunction( ScalarFunction({LogicalType::STRUCT(make_date_children)}, LogicalType::DATE, ExecuteStructMakeDate)); + for (auto &func : make_date.functions) { + BaseScalarFunction::SetReturnsError(func); + } return make_date; } ScalarFunction MakeTimeFun::GetFunction() { - return ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::DOUBLE}, LogicalType::TIME, - ExecuteMakeTime); + ScalarFunction function({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::DOUBLE}, LogicalType::TIME, + ExecuteMakeTime); + BaseScalarFunction::SetReturnsError(function); + return function; } ScalarFunctionSet MakeTimestampFun::GetFunctions() { @@ -155,6 +160,10 @@ ScalarFunctionSet MakeTimestampFun::GetFunctions() { LogicalType::TIMESTAMP, ExecuteMakeTimestamp)); operator_set.AddFunction( ScalarFunction({LogicalType::BIGINT}, LogicalType::TIMESTAMP, ExecuteMakeTimestamp)); + + for (auto &func : operator_set.functions) { + BaseScalarFunction::SetReturnsError(func); + } return operator_set; } diff --git a/src/duckdb/extension/core_functions/scalar/date/time_bucket.cpp b/src/duckdb/extension/core_functions/scalar/date/time_bucket.cpp index 3c8c2719b..726d6b54f 100644 --- a/src/duckdb/extension/core_functions/scalar/date/time_bucket.cpp +++ b/src/duckdb/extension/core_functions/scalar/date/time_bucket.cpp @@ -364,6 +364,9 @@ ScalarFunctionSet TimeBucketFun::GetFunctions() { LogicalType::DATE, TimeBucketOriginFunction)); time_bucket.AddFunction(ScalarFunction({LogicalType::INTERVAL, LogicalType::TIMESTAMP, LogicalType::TIMESTAMP}, LogicalType::TIMESTAMP, TimeBucketOriginFunction)); + for (auto &func : time_bucket.functions) { + BaseScalarFunction::SetReturnsError(func); + } return time_bucket; } diff --git a/src/duckdb/extension/core_functions/scalar/date/to_interval.cpp b/src/duckdb/extension/core_functions/scalar/date/to_interval.cpp index 204f49642..c8d508883 100644 --- a/src/duckdb/extension/core_functions/scalar/date/to_interval.cpp +++ b/src/duckdb/extension/core_functions/scalar/date/to_interval.cpp @@ -165,68 +165,94 @@ struct ToMicroSecondsOperator { }; ScalarFunction ToMillenniaFun::GetFunction() { - return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL, - ScalarFunction::UnaryFunction); + ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL, + ScalarFunction::UnaryFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } ScalarFunction ToCenturiesFun::GetFunction() { - return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL, - ScalarFunction::UnaryFunction); + ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL, + ScalarFunction::UnaryFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } ScalarFunction ToDecadesFun::GetFunction() { - return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL, - ScalarFunction::UnaryFunction); + ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL, + ScalarFunction::UnaryFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } ScalarFunction ToYearsFun::GetFunction() { - return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL, - ScalarFunction::UnaryFunction); + ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL, + ScalarFunction::UnaryFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } ScalarFunction ToQuartersFun::GetFunction() { - return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL, - ScalarFunction::UnaryFunction); + ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL, + ScalarFunction::UnaryFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } ScalarFunction ToMonthsFun::GetFunction() { - return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL, - ScalarFunction::UnaryFunction); + ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL, + ScalarFunction::UnaryFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } ScalarFunction ToWeeksFun::GetFunction() { - return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL, - ScalarFunction::UnaryFunction); + ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL, + ScalarFunction::UnaryFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } ScalarFunction ToDaysFun::GetFunction() { - return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL, - ScalarFunction::UnaryFunction); + ScalarFunction function({LogicalType::INTEGER}, LogicalType::INTERVAL, + ScalarFunction::UnaryFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } ScalarFunction ToHoursFun::GetFunction() { - return ScalarFunction({LogicalType::BIGINT}, LogicalType::INTERVAL, - ScalarFunction::UnaryFunction); + ScalarFunction function({LogicalType::BIGINT}, LogicalType::INTERVAL, + ScalarFunction::UnaryFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } ScalarFunction ToMinutesFun::GetFunction() { - return ScalarFunction({LogicalType::BIGINT}, LogicalType::INTERVAL, - ScalarFunction::UnaryFunction); + ScalarFunction function({LogicalType::BIGINT}, LogicalType::INTERVAL, + ScalarFunction::UnaryFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } ScalarFunction ToSecondsFun::GetFunction() { - return ScalarFunction({LogicalType::DOUBLE}, LogicalType::INTERVAL, - ScalarFunction::UnaryFunction); + ScalarFunction function({LogicalType::DOUBLE}, LogicalType::INTERVAL, + ScalarFunction::UnaryFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } ScalarFunction ToMillisecondsFun::GetFunction() { - return ScalarFunction({LogicalType::DOUBLE}, LogicalType::INTERVAL, - ScalarFunction::UnaryFunction); + ScalarFunction function({LogicalType::DOUBLE}, LogicalType::INTERVAL, + ScalarFunction::UnaryFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } ScalarFunction ToMicrosecondsFun::GetFunction() { - return ScalarFunction({LogicalType::BIGINT}, LogicalType::INTERVAL, - ScalarFunction::UnaryFunction); + ScalarFunction function({LogicalType::BIGINT}, LogicalType::INTERVAL, + ScalarFunction::UnaryFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } } // namespace duckdb diff --git a/src/duckdb/extension/core_functions/scalar/generic/binning.cpp b/src/duckdb/extension/core_functions/scalar/generic/binning.cpp index 6e6c6c6c7..83f7c0700 100644 --- a/src/duckdb/extension/core_functions/scalar/generic/binning.cpp +++ b/src/duckdb/extension/core_functions/scalar/generic/binning.cpp @@ -500,6 +500,7 @@ ScalarFunctionSet EquiWidthBinsFun::GetFunctions() { for (auto &function : functions.functions) { function.serialize = EquiWidthBinSerialize; function.deserialize = EquiWidthBinDeserialize; + BaseScalarFunction::SetReturnsError(function); } return functions; } diff --git a/src/duckdb/extension/core_functions/scalar/list/array_slice.cpp b/src/duckdb/extension/core_functions/scalar/list/array_slice.cpp index 6aa110781..0962b3c2e 100644 --- a/src/duckdb/extension/core_functions/scalar/list/array_slice.cpp +++ b/src/duckdb/extension/core_functions/scalar/list/array_slice.cpp @@ -449,7 +449,7 @@ ScalarFunctionSet ListSliceFun::GetFunctions() { ScalarFunction fun({LogicalType::ANY, LogicalType::ANY, LogicalType::ANY}, LogicalType::ANY, ArraySliceFunction, ArraySliceBind); fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING; - + BaseScalarFunction::SetReturnsError(fun); ScalarFunctionSet set; set.AddFunction(fun); fun.arguments.push_back(LogicalType::BIGINT); diff --git a/src/duckdb/extension/core_functions/scalar/list/list_aggregates.cpp b/src/duckdb/extension/core_functions/scalar/list/list_aggregates.cpp index 6b94bf602..1b2aab71d 100644 --- a/src/duckdb/extension/core_functions/scalar/list/list_aggregates.cpp +++ b/src/duckdb/extension/core_functions/scalar/list/list_aggregates.cpp @@ -468,6 +468,7 @@ static unique_ptr ListAggregatesBind(ClientContext &context, Scala // found a matching function, bind it as an aggregate auto best_function = func.functions.GetFunctionByOffset(best_function_idx.GetIndex()); if (IS_AGGR) { + bound_function.errors = best_function.errors; return ListAggregatesBindFunction(context, bound_function, child_type, best_function, arguments); } @@ -512,6 +513,7 @@ static unique_ptr ListUniqueBind(ClientContext &context, ScalarFun ScalarFunction ListAggregateFun::GetFunction() { auto result = ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::VARCHAR}, LogicalType::ANY, ListAggregateFunction, ListAggregateBind); + BaseScalarFunction::SetReturnsError(result); result.null_handling = FunctionNullHandling::SPECIAL_HANDLING; result.varargs = LogicalType::ANY; result.serialize = ListAggregatesBindData::SerializeFunction; diff --git a/src/duckdb/extension/core_functions/scalar/list/list_distance.cpp b/src/duckdb/extension/core_functions/scalar/list/list_distance.cpp index f4c420986..5c3513b2a 100644 --- a/src/duckdb/extension/core_functions/scalar/list/list_distance.cpp +++ b/src/duckdb/extension/core_functions/scalar/list/list_distance.cpp @@ -87,6 +87,9 @@ ScalarFunctionSet ListDistanceFun::GetFunctions() { for (auto &type : LogicalType::Real()) { AddListFoldFunction(set, type); } + for (auto &func : set.functions) { + BaseScalarFunction::SetReturnsError(func); + } return set; } @@ -111,6 +114,9 @@ ScalarFunctionSet ListCosineSimilarityFun::GetFunctions() { for (auto &type : LogicalType::Real()) { AddListFoldFunction(set, type); } + for (auto &func : set.functions) { + BaseScalarFunction::SetReturnsError(func); + } return set; } diff --git a/src/duckdb/extension/core_functions/scalar/list/range.cpp b/src/duckdb/extension/core_functions/scalar/list/range.cpp index 174fcb9c9..8c641d13d 100644 --- a/src/duckdb/extension/core_functions/scalar/list/range.cpp +++ b/src/duckdb/extension/core_functions/scalar/list/range.cpp @@ -253,6 +253,9 @@ ScalarFunctionSet ListRangeFun::GetFunctions() { range_set.AddFunction(ScalarFunction({LogicalType::TIMESTAMP, LogicalType::TIMESTAMP, LogicalType::INTERVAL}, LogicalType::LIST(LogicalType::TIMESTAMP), ListRangeFunction)); + for (auto &func : range_set.functions) { + BaseScalarFunction::SetReturnsError(func); + } return range_set; } @@ -269,6 +272,9 @@ ScalarFunctionSet GenerateSeriesFun::GetFunctions() { generate_series.AddFunction(ScalarFunction({LogicalType::TIMESTAMP, LogicalType::TIMESTAMP, LogicalType::INTERVAL}, LogicalType::LIST(LogicalType::TIMESTAMP), ListRangeFunction)); + for (auto &func : generate_series.functions) { + BaseScalarFunction::SetReturnsError(func); + } return generate_series; } diff --git a/src/duckdb/extension/core_functions/scalar/map/map.cpp b/src/duckdb/extension/core_functions/scalar/map/map.cpp index 7e39554e7..b83a4a081 100644 --- a/src/duckdb/extension/core_functions/scalar/map/map.cpp +++ b/src/duckdb/extension/core_functions/scalar/map/map.cpp @@ -215,6 +215,7 @@ static unique_ptr MapBind(ClientContext &, ScalarFunction &bound_f ScalarFunction MapFun::GetFunction() { ScalarFunction fun({}, LogicalTypeId::MAP, MapFunction, MapBind); fun.varargs = LogicalType::ANY; + BaseScalarFunction::SetReturnsError(fun); fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING; return fun; } diff --git a/src/duckdb/extension/core_functions/scalar/map/map_from_entries.cpp b/src/duckdb/extension/core_functions/scalar/map/map_from_entries.cpp index 8fb23e410..edbe1d4fb 100644 --- a/src/duckdb/extension/core_functions/scalar/map/map_from_entries.cpp +++ b/src/duckdb/extension/core_functions/scalar/map/map_from_entries.cpp @@ -53,6 +53,7 @@ ScalarFunction MapFromEntriesFun::GetFunction() { ScalarFunction fun({}, LogicalTypeId::MAP, MapFromEntriesFunction, MapFromEntriesBind); fun.null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING; fun.varargs = LogicalType::ANY; + BaseScalarFunction::SetReturnsError(fun); return fun; } diff --git a/src/duckdb/extension/core_functions/scalar/map/map_keys_values.cpp b/src/duckdb/extension/core_functions/scalar/map/map_keys_values.cpp index 4107029bc..6d99a353e 100644 --- a/src/duckdb/extension/core_functions/scalar/map/map_keys_values.cpp +++ b/src/duckdb/extension/core_functions/scalar/map/map_keys_values.cpp @@ -94,17 +94,19 @@ static unique_ptr MapValuesBind(ClientContext &context, ScalarFunc ScalarFunction MapKeysFun::GetFunction() { //! the arguments and return types are actually set in the binder function - ScalarFunction fun({}, LogicalTypeId::LIST, MapKeysFunction, MapKeysBind); - fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING; - fun.varargs = LogicalType::ANY; - return fun; + ScalarFunction function({}, LogicalTypeId::LIST, MapKeysFunction, MapKeysBind); + function.null_handling = FunctionNullHandling::SPECIAL_HANDLING; + BaseScalarFunction::SetReturnsError(function); + function.varargs = LogicalType::ANY; + return function; } ScalarFunction MapValuesFun::GetFunction() { - ScalarFunction fun({}, LogicalTypeId::LIST, MapValuesFunction, MapValuesBind); - fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING; - fun.varargs = LogicalType::ANY; - return fun; + ScalarFunction function({}, LogicalTypeId::LIST, MapValuesFunction, MapValuesBind); + function.null_handling = FunctionNullHandling::SPECIAL_HANDLING; + BaseScalarFunction::SetReturnsError(function); + function.varargs = LogicalType::ANY; + return function; } } // namespace duckdb diff --git a/src/duckdb/extension/core_functions/scalar/math/numeric.cpp b/src/duckdb/extension/core_functions/scalar/math/numeric.cpp index b69b38f93..47eed7a79 100644 --- a/src/duckdb/extension/core_functions/scalar/math/numeric.cpp +++ b/src/duckdb/extension/core_functions/scalar/math/numeric.cpp @@ -178,9 +178,9 @@ ScalarFunctionSet AbsOperatorFun::GetFunctions() { case LogicalTypeId::INTEGER: case LogicalTypeId::BIGINT: case LogicalTypeId::HUGEINT: { - ScalarFunction func({type}, type, ScalarFunction::GetScalarUnaryFunction(type)); - func.statistics = PropagateAbsStats; - abs.AddFunction(func); + ScalarFunction function({type}, type, ScalarFunction::GetScalarUnaryFunction(type)); + function.statistics = PropagateAbsStats; + abs.AddFunction(function); break; } case LogicalTypeId::UTINYINT: @@ -194,6 +194,9 @@ ScalarFunctionSet AbsOperatorFun::GetFunctions() { break; } } + for (auto &func : abs.functions) { + BaseScalarFunction::SetReturnsError(func); + } return abs; } @@ -765,8 +768,10 @@ struct SqrtOperator { }; ScalarFunction SqrtFun::GetFunction() { - return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE, - ScalarFunction::UnaryFunction); + ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE, + ScalarFunction::UnaryFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } //===--------------------------------------------------------------------===// @@ -802,8 +807,10 @@ struct LnOperator { }; ScalarFunction LnFun::GetFunction() { - return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE, - ScalarFunction::UnaryFunction); + ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE, + ScalarFunction::UnaryFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } //===--------------------------------------------------------------------===// @@ -823,8 +830,10 @@ struct Log10Operator { }; ScalarFunction Log10Fun::GetFunction() { - return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE, - ScalarFunction::UnaryFunction); + ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE, + ScalarFunction::UnaryFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } //===--------------------------------------------------------------------===// @@ -847,6 +856,9 @@ ScalarFunctionSet LogFun::GetFunctions() { ScalarFunction::UnaryFunction)); funcs.AddFunction(ScalarFunction({LogicalType::DOUBLE, LogicalType::DOUBLE}, LogicalType::DOUBLE, ScalarFunction::BinaryFunction)); + for (auto &function : funcs.functions) { + BaseScalarFunction::SetReturnsError(function); + } return funcs; } @@ -867,8 +879,10 @@ struct Log2Operator { }; ScalarFunction Log2Fun::GetFunction() { - return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE, - ScalarFunction::UnaryFunction); + ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE, + ScalarFunction::UnaryFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } //===--------------------------------------------------------------------===// @@ -1037,8 +1051,10 @@ struct SinOperator { }; ScalarFunction SinFun::GetFunction() { - return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE, - ScalarFunction::UnaryFunction>); + ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE, + ScalarFunction::UnaryFunction>); + BaseScalarFunction::SetReturnsError(function); + return function; } //===--------------------------------------------------------------------===// @@ -1052,8 +1068,10 @@ struct CosOperator { }; ScalarFunction CosFun::GetFunction() { - return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE, - ScalarFunction::UnaryFunction>); + ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE, + ScalarFunction::UnaryFunction>); + BaseScalarFunction::SetReturnsError(function); + return function; } //===--------------------------------------------------------------------===// @@ -1067,8 +1085,10 @@ struct TanOperator { }; ScalarFunction TanFun::GetFunction() { - return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE, - ScalarFunction::UnaryFunction>); + ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE, + ScalarFunction::UnaryFunction>); + BaseScalarFunction::SetReturnsError(function); + return function; } //===--------------------------------------------------------------------===// @@ -1085,8 +1105,10 @@ struct ASinOperator { }; ScalarFunction AsinFun::GetFunction() { - return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE, - ScalarFunction::UnaryFunction>); + ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE, + ScalarFunction::UnaryFunction>); + BaseScalarFunction::SetReturnsError(function); + return function; } //===--------------------------------------------------------------------===// @@ -1133,8 +1155,10 @@ struct ACos { }; ScalarFunction AcosFun::GetFunction() { - return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE, - ScalarFunction::UnaryFunction>); + ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE, + ScalarFunction::UnaryFunction>); + BaseScalarFunction::SetReturnsError(function); + return function; } //===--------------------------------------------------------------------===// @@ -1229,8 +1253,10 @@ struct AtanhOperator { }; ScalarFunction AtanhFun::GetFunction() { - return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE, - ScalarFunction::UnaryFunction); + ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE, + ScalarFunction::UnaryFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } //===--------------------------------------------------------------------===// @@ -1261,8 +1287,10 @@ struct CotOperator { }; ScalarFunction CotFun::GetFunction() { - return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE, - ScalarFunction::UnaryFunction>); + ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE, + ScalarFunction::UnaryFunction>); + BaseScalarFunction::SetReturnsError(function); + return function; } //===--------------------------------------------------------------------===// @@ -1279,8 +1307,10 @@ struct GammaOperator { }; ScalarFunction GammaFun::GetFunction() { - return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE, - ScalarFunction::UnaryFunction); + auto func = ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE, + ScalarFunction::UnaryFunction); + BaseScalarFunction::SetReturnsError(func); + return func; } //===--------------------------------------------------------------------===// @@ -1297,8 +1327,10 @@ struct LogGammaOperator { }; ScalarFunction LogGammaFun::GetFunction() { - return ScalarFunction({LogicalType::DOUBLE}, LogicalType::DOUBLE, - ScalarFunction::UnaryFunction); + ScalarFunction function({LogicalType::DOUBLE}, LogicalType::DOUBLE, + ScalarFunction::UnaryFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } //===--------------------------------------------------------------------===// @@ -1318,8 +1350,10 @@ struct FactorialOperator { }; ScalarFunction FactorialOperatorFun::GetFunction() { - return ScalarFunction({LogicalType::INTEGER}, LogicalType::HUGEINT, - ScalarFunction::UnaryFunction); + ScalarFunction function({LogicalType::INTEGER}, LogicalType::HUGEINT, + ScalarFunction::UnaryFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } //===--------------------------------------------------------------------===// @@ -1426,6 +1460,9 @@ ScalarFunctionSet LeastCommonMultipleFun::GetFunctions() { funcs.AddFunction( ScalarFunction({LogicalType::HUGEINT, LogicalType::HUGEINT}, LogicalType::HUGEINT, ScalarFunction::BinaryFunction)); + for (auto &function : funcs.functions) { + BaseScalarFunction::SetReturnsError(function); + } return funcs; } diff --git a/src/duckdb/extension/core_functions/scalar/operators/bitwise.cpp b/src/duckdb/extension/core_functions/scalar/operators/bitwise.cpp index 8e4a04762..103e0c2ab 100644 --- a/src/duckdb/extension/core_functions/scalar/operators/bitwise.cpp +++ b/src/duckdb/extension/core_functions/scalar/operators/bitwise.cpp @@ -112,6 +112,9 @@ ScalarFunctionSet BitwiseAndFun::GetFunctions() { ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction(type))); } functions.AddFunction(ScalarFunction({LogicalType::BIT, LogicalType::BIT}, LogicalType::BIT, BitwiseANDOperation)); + for (auto &function : functions.functions) { + BaseScalarFunction::SetReturnsError(function); + } return functions; } @@ -142,6 +145,9 @@ ScalarFunctionSet BitwiseOrFun::GetFunctions() { ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction(type))); } functions.AddFunction(ScalarFunction({LogicalType::BIT, LogicalType::BIT}, LogicalType::BIT, BitwiseOROperation)); + for (auto &function : functions.functions) { + BaseScalarFunction::SetReturnsError(function); + } return functions; } @@ -172,6 +178,9 @@ ScalarFunctionSet BitwiseXorFun::GetFunctions() { ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction(type))); } functions.AddFunction(ScalarFunction({LogicalType::BIT, LogicalType::BIT}, LogicalType::BIT, BitwiseXOROperation)); + for (auto &function : functions.functions) { + BaseScalarFunction::SetReturnsError(function); + } return functions; } @@ -200,6 +209,9 @@ ScalarFunctionSet BitwiseNotFun::GetFunctions() { functions.AddFunction(ScalarFunction({type}, type, GetScalarIntegerUnaryFunction(type))); } functions.AddFunction(ScalarFunction({LogicalType::BIT}, LogicalType::BIT, BitwiseNOTOperation)); + for (auto &function : functions.functions) { + BaseScalarFunction::SetReturnsError(function); + } return functions; } @@ -263,6 +275,9 @@ ScalarFunctionSet LeftShiftFun::GetFunctions() { } functions.AddFunction( ScalarFunction({LogicalType::BIT, LogicalType::INTEGER}, LogicalType::BIT, BitwiseShiftLeftOperation)); + for (auto &function : functions.functions) { + BaseScalarFunction::SetReturnsError(function); + } return functions; } @@ -306,6 +321,9 @@ ScalarFunctionSet RightShiftFun::GetFunctions() { } functions.AddFunction( ScalarFunction({LogicalType::BIT, LogicalType::INTEGER}, LogicalType::BIT, BitwiseShiftRightOperation)); + for (auto &function : functions.functions) { + BaseScalarFunction::SetReturnsError(function); + } return functions; } diff --git a/src/duckdb/extension/core_functions/scalar/random/setseed.cpp b/src/duckdb/extension/core_functions/scalar/random/setseed.cpp index 8c2e6739b..ca2865284 100644 --- a/src/duckdb/extension/core_functions/scalar/random/setseed.cpp +++ b/src/duckdb/extension/core_functions/scalar/random/setseed.cpp @@ -55,6 +55,7 @@ unique_ptr SetSeedBind(ClientContext &context, ScalarFunction &bou ScalarFunction SetseedFun::GetFunction() { ScalarFunction setseed("setseed", {LogicalType::DOUBLE}, LogicalType::SQLNULL, SetSeedFunction, SetSeedBind); setseed.stability = FunctionStability::VOLATILE; + BaseScalarFunction::SetReturnsError(setseed); return setseed; } diff --git a/src/duckdb/extension/core_functions/scalar/string/hex.cpp b/src/duckdb/extension/core_functions/scalar/string/hex.cpp index 3783933c4..cbf541e1b 100644 --- a/src/duckdb/extension/core_functions/scalar/string/hex.cpp +++ b/src/duckdb/extension/core_functions/scalar/string/hex.cpp @@ -408,7 +408,9 @@ ScalarFunctionSet HexFun::GetFunctions() { } ScalarFunction UnhexFun::GetFunction() { - return ScalarFunction({LogicalType::VARCHAR}, LogicalType::BLOB, FromHexFunction); + ScalarFunction function({LogicalType::VARCHAR}, LogicalType::BLOB, FromHexFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } ScalarFunctionSet BinFun::GetFunctions() { @@ -430,7 +432,9 @@ ScalarFunctionSet BinFun::GetFunctions() { } ScalarFunction UnbinFun::GetFunction() { - return ScalarFunction({LogicalType::VARCHAR}, LogicalType::BLOB, FromBinaryFunction); + ScalarFunction function({LogicalType::VARCHAR}, LogicalType::BLOB, FromBinaryFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } } // namespace duckdb diff --git a/src/duckdb/extension/core_functions/scalar/string/pad.cpp b/src/duckdb/extension/core_functions/scalar/string/pad.cpp index 0c6a3ad8a..586e1605a 100644 --- a/src/duckdb/extension/core_functions/scalar/string/pad.cpp +++ b/src/duckdb/extension/core_functions/scalar/string/pad.cpp @@ -131,13 +131,17 @@ static void PadFunction(DataChunk &args, ExpressionState &state, Vector &result) } ScalarFunction LpadFun::GetFunction() { - return ScalarFunction({LogicalType::VARCHAR, LogicalType::INTEGER, LogicalType::VARCHAR}, LogicalType::VARCHAR, - PadFunction); + ScalarFunction func({LogicalType::VARCHAR, LogicalType::INTEGER, LogicalType::VARCHAR}, LogicalType::VARCHAR, + PadFunction); + BaseScalarFunction::SetReturnsError(func); + return func; } ScalarFunction RpadFun::GetFunction() { - return ScalarFunction({LogicalType::VARCHAR, LogicalType::INTEGER, LogicalType::VARCHAR}, LogicalType::VARCHAR, - PadFunction); + ScalarFunction func({LogicalType::VARCHAR, LogicalType::INTEGER, LogicalType::VARCHAR}, LogicalType::VARCHAR, + PadFunction); + BaseScalarFunction::SetReturnsError(func); + return func; } } // namespace duckdb diff --git a/src/duckdb/extension/core_functions/scalar/string/printf.cpp b/src/duckdb/extension/core_functions/scalar/string/printf.cpp index 2839fdf22..1db25b0df 100644 --- a/src/duckdb/extension/core_functions/scalar/string/printf.cpp +++ b/src/duckdb/extension/core_functions/scalar/string/printf.cpp @@ -173,6 +173,7 @@ ScalarFunction PrintfFun::GetFunction() { ScalarFunction printf_fun({LogicalType::VARCHAR}, LogicalType::VARCHAR, PrintfFunction, BindPrintfFunction); printf_fun.varargs = LogicalType::ANY; + BaseScalarFunction::SetReturnsError(printf_fun); return printf_fun; } @@ -181,6 +182,7 @@ ScalarFunction FormatFun::GetFunction() { ScalarFunction format_fun({LogicalType::VARCHAR}, LogicalType::VARCHAR, PrintfFunction, BindPrintfFunction); format_fun.varargs = LogicalType::ANY; + BaseScalarFunction::SetReturnsError(format_fun); return format_fun; } diff --git a/src/duckdb/extension/core_functions/scalar/string/repeat.cpp b/src/duckdb/extension/core_functions/scalar/string/repeat.cpp index a6117d706..154634f94 100644 --- a/src/duckdb/extension/core_functions/scalar/string/repeat.cpp +++ b/src/duckdb/extension/core_functions/scalar/string/repeat.cpp @@ -81,6 +81,9 @@ ScalarFunctionSet RepeatFun::GetFunctions() { } repeat.AddFunction(ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::BIGINT}, LogicalType::LIST(LogicalType::ANY), RepeatListFunction, RepeatBindFunction)); + for (auto &func : repeat.functions) { + BaseScalarFunction::SetReturnsError(func); + } return repeat; } diff --git a/src/duckdb/extension/icu/icu-datepart.cpp b/src/duckdb/extension/icu/icu-datepart.cpp index 2137afd48..87805798c 100644 --- a/src/duckdb/extension/icu/icu-datepart.cpp +++ b/src/duckdb/extension/icu/icu-datepart.cpp @@ -610,6 +610,9 @@ struct ICUDatePart : public ICUDateFunc { ScalarFunctionSet set(name); set.AddFunction(GetBinaryPartCodeFunction(LogicalType::TIMESTAMP_TZ)); set.AddFunction(GetStructFunction(LogicalType::TIMESTAMP_TZ)); + for (auto &func : set.functions) { + BaseScalarFunction::SetReturnsError(func); + } ExtensionUtil::RegisterFunction(db, set); } diff --git a/src/duckdb/extension/icu/icu-makedate.cpp b/src/duckdb/extension/icu/icu-makedate.cpp index bcc78e4b0..ce09476dd 100644 --- a/src/duckdb/extension/icu/icu-makedate.cpp +++ b/src/duckdb/extension/icu/icu-makedate.cpp @@ -137,21 +137,27 @@ struct ICUMakeTimestampTZFunc : public ICUDateFunc { template static ScalarFunction GetSenaryFunction(const LogicalTypeId &type) { - return ScalarFunction({type, type, type, type, type, LogicalType::DOUBLE}, LogicalType::TIMESTAMP_TZ, - Execute, Bind); + ScalarFunction function({type, type, type, type, type, LogicalType::DOUBLE}, LogicalType::TIMESTAMP_TZ, + Execute, Bind); + BaseScalarFunction::SetReturnsError(function); + return function; } template static ScalarFunction GetSeptenaryFunction(const LogicalTypeId &type) { - return ScalarFunction({type, type, type, type, type, LogicalType::DOUBLE, LogicalType::VARCHAR}, - LogicalType::TIMESTAMP_TZ, Execute, Bind); + ScalarFunction function({type, type, type, type, type, LogicalType::DOUBLE, LogicalType::VARCHAR}, + LogicalType::TIMESTAMP_TZ, Execute, Bind); + BaseScalarFunction::SetReturnsError(function); + return function; } static void AddFunction(const string &name, DatabaseInstance &db) { ScalarFunctionSet set(name); set.AddFunction(GetSenaryFunction(LogicalType::BIGINT)); set.AddFunction(GetSeptenaryFunction(LogicalType::BIGINT)); - set.AddFunction(ScalarFunction({LogicalType::BIGINT}, LogicalType::TIMESTAMP_TZ, FromMicros)); + ScalarFunction function({LogicalType::BIGINT}, LogicalType::TIMESTAMP_TZ, FromMicros); + BaseScalarFunction::SetReturnsError(function); + set.AddFunction(function); ExtensionUtil::RegisterFunction(db, set); } }; diff --git a/src/duckdb/extension/icu/icu-timebucket.cpp b/src/duckdb/extension/icu/icu-timebucket.cpp index 11b4c7df9..ffb62ca1b 100644 --- a/src/duckdb/extension/icu/icu-timebucket.cpp +++ b/src/duckdb/extension/icu/icu-timebucket.cpp @@ -631,6 +631,9 @@ struct ICUTimeBucket : public ICUDateFunc { LogicalType::TIMESTAMP_TZ, ICUTimeBucketOriginFunction, Bind)); set.AddFunction(ScalarFunction({LogicalType::INTERVAL, LogicalType::TIMESTAMP_TZ, LogicalType::VARCHAR}, LogicalType::TIMESTAMP_TZ, ICUTimeBucketTimeZoneFunction, Bind)); + for (auto &func : set.functions) { + BaseScalarFunction::SetReturnsError(func); + } ExtensionUtil::RegisterFunction(db, set); } }; diff --git a/src/duckdb/extension/icu/icu-timezone.cpp b/src/duckdb/extension/icu/icu-timezone.cpp index 0aa8828c5..f9788f67d 100644 --- a/src/duckdb/extension/icu/icu-timezone.cpp +++ b/src/duckdb/extension/icu/icu-timezone.cpp @@ -444,6 +444,9 @@ struct ICUTimeZoneFunc : public ICUDateFunc { Execute, Bind)); set.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIME_TZ}, LogicalType::TIME_TZ, Execute, Bind)); + for (auto &func : set.functions) { + BaseScalarFunction::SetReturnsError(func); + } ExtensionUtil::RegisterFunction(db, set); } }; diff --git a/src/duckdb/src/common/enum_util.cpp b/src/duckdb/src/common/enum_util.cpp index 1e6af4058..23d9c6e27 100644 --- a/src/duckdb/src/common/enum_util.cpp +++ b/src/duckdb/src/common/enum_util.cpp @@ -636,19 +636,20 @@ const StringUtil::EnumStringLiteral *GetCSVStateValues() { { static_cast(CSVState::COMMENT), "COMMENT" }, { static_cast(CSVState::STANDARD_NEWLINE), "STANDARD_NEWLINE" }, { static_cast(CSVState::UNQUOTED_ESCAPE), "UNQUOTED_ESCAPE" }, - { static_cast(CSVState::ESCAPED_RETURN), "ESCAPED_RETURN" } + { static_cast(CSVState::ESCAPED_RETURN), "ESCAPED_RETURN" }, + { static_cast(CSVState::MAYBE_QUOTED), "MAYBE_QUOTED" } }; return values; } template<> const char* EnumUtil::ToChars(CSVState value) { - return StringUtil::EnumToString(GetCSVStateValues(), 18, "CSVState", static_cast(value)); + return StringUtil::EnumToString(GetCSVStateValues(), 19, "CSVState", static_cast(value)); } template<> CSVState EnumUtil::FromString(const char *value) { - return static_cast(StringUtil::StringToEnum(GetCSVStateValues(), 18, "CSVState", value)); + return static_cast(StringUtil::StringToEnum(GetCSVStateValues(), 19, "CSVState", value)); } const StringUtil::EnumStringLiteral *GetCTEMaterializeValues() { @@ -1747,7 +1748,7 @@ FunctionCollationHandling EnumUtil::FromString(const const StringUtil::EnumStringLiteral *GetFunctionErrorsValues() { static constexpr StringUtil::EnumStringLiteral values[] { { static_cast(FunctionErrors::CANNOT_ERROR), "CANNOT_ERROR" }, - { static_cast(FunctionErrors::CAN_THROW_ERROR), "CAN_THROW_ERROR" } + { static_cast(FunctionErrors::CAN_THROW_RUNTIME_ERROR), "CAN_THROW_RUNTIME_ERROR" } }; return values; } diff --git a/src/duckdb/src/execution/expression_executor/execute_function.cpp b/src/duckdb/src/execution/expression_executor/execute_function.cpp index 7fe9df2f5..5a95d27a3 100644 --- a/src/duckdb/src/execution/expression_executor/execute_function.cpp +++ b/src/duckdb/src/execution/expression_executor/execute_function.cpp @@ -76,6 +76,7 @@ void ExpressionExecutor::Execute(const BoundFunctionExpression &expr, Expression arguments.Verify(); D_ASSERT(expr.function.function); + // #ifdef DEBUG expr.function.function(arguments, *state, result); VerifyNullHandling(expr, arguments, result); 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 c9c8141da..8d78e6653 100644 --- a/src/duckdb/src/execution/operator/aggregate/physical_streaming_window.cpp +++ b/src/duckdb/src/execution/operator/aggregate/physical_streaming_window.cpp @@ -332,7 +332,7 @@ class StreamingWindowState : public OperatorState { bool PhysicalStreamingWindow::IsStreamingFunction(ClientContext &context, unique_ptr &expr) { auto &wexpr = expr->Cast(); - if (!wexpr.partitions.empty() || !wexpr.orders.empty() || wexpr.ignore_nulls || + if (!wexpr.partitions.empty() || !wexpr.orders.empty() || wexpr.ignore_nulls || !wexpr.arg_orders.empty() || wexpr.exclude_clause != WindowExcludeMode::NO_OTHER) { return false; } diff --git a/src/duckdb/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp b/src/duckdb/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp index 27820b247..7e3df336a 100644 --- a/src/duckdb/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp +++ b/src/duckdb/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp @@ -528,6 +528,7 @@ void StringValueResult::AddPossiblyEscapedValue(StringValueResult &result, const } else { auto value = StringValueScanner::RemoveEscape( value_ptr, length, result.state_machine.dialect_options.state_machine_options.escape.GetValue(), + result.state_machine.dialect_options.state_machine_options.quote.GetValue(), result.parse_chunk.data[result.chunk_col_id]); result.AddValueToVector(value.GetData(), value.GetSize()); } @@ -1210,13 +1211,18 @@ void StringValueScanner::ProcessExtraRow() { } } -string_t StringValueScanner::RemoveEscape(const char *str_ptr, idx_t end, char escape, Vector &vector) { +string_t StringValueScanner::RemoveEscape(const char *str_ptr, idx_t end, char escape, char quote, Vector &vector) { // Figure out the exact size idx_t str_pos = 0; bool just_escaped = false; for (idx_t cur_pos = 0; cur_pos < end; cur_pos++) { if (str_ptr[cur_pos] == escape && !just_escaped) { just_escaped = true; + } else if (str_ptr[cur_pos] == quote) { + if (just_escaped) { + str_pos++; + } + just_escaped = false; } else { just_escaped = false; str_pos++; @@ -1229,9 +1235,14 @@ string_t StringValueScanner::RemoveEscape(const char *str_ptr, idx_t end, char e str_pos = 0; just_escaped = false; for (idx_t cur_pos = 0; cur_pos < end; cur_pos++) { - char c = str_ptr[cur_pos]; + const char c = str_ptr[cur_pos]; if (c == escape && !just_escaped) { just_escaped = true; + } else if (str_ptr[cur_pos] == quote) { + if (just_escaped) { + removed_escapes_ptr[str_pos++] = c; + } + just_escaped = false; } else { just_escaped = false; removed_escapes_ptr[str_pos++] = c; @@ -1269,7 +1280,7 @@ void StringValueScanner::ProcessOverBufferValue() { if (states.IsUnquoted()) { result.SetUnquoted(result); } - if (states.IsEscaped()) { + if (states.IsEscaped() && result.state_machine.dialect_options.state_machine_options.escape != '\0') { result.escaped = true; } if (states.IsComment()) { @@ -1309,7 +1320,7 @@ void StringValueScanner::ProcessOverBufferValue() { if (states.IsComment()) { result.comment = true; } - if (states.IsEscaped()) { + if (states.IsEscaped() && result.state_machine.dialect_options.state_machine_options.escape != '\0') { result.escaped = true; } if (states.IsInvalid()) { @@ -1334,6 +1345,7 @@ void StringValueScanner::ProcessOverBufferValue() { const auto str_ptr = over_buffer_string.c_str() + result.quoted_position; value = RemoveEscape(str_ptr, over_buffer_string.size() - 2, state_machine->dialect_options.state_machine_options.escape.GetValue(), + state_machine->dialect_options.state_machine_options.quote.GetValue(), result.parse_chunk.data[result.chunk_col_id]); } } @@ -1343,6 +1355,7 @@ void StringValueScanner::ProcessOverBufferValue() { if (!result.HandleTooManyColumnsError(over_buffer_string.c_str(), over_buffer_string.size())) { value = RemoveEscape(over_buffer_string.c_str(), over_buffer_string.size(), state_machine->dialect_options.state_machine_options.escape.GetValue(), + state_machine->dialect_options.state_machine_options.quote.GetValue(), result.parse_chunk.data[result.chunk_col_id]); } } @@ -1419,7 +1432,8 @@ bool StringValueScanner::MoveToNextBuffer() { result.AddRow(result, previous_buffer_handle->actual_size); } lines_read++; - } else if (states.IsQuotedCurrent()) { + } else if (states.IsQuotedCurrent() && + state_machine->dialect_options.state_machine_options.rfc_4180.GetValue()) { // Unterminated quote LinePosition current_line_start = {iterator.pos.buffer_idx, iterator.pos.buffer_pos, result.buffer_size}; @@ -1430,7 +1444,8 @@ bool StringValueScanner::MoveToNextBuffer() { if (result.IsCommentSet(result)) { result.UnsetComment(result, iterator.pos.buffer_pos); } else { - if (result.quoted && states.IsDelimiterBytes()) { + if (result.quoted && states.IsDelimiterBytes() && + state_machine->dialect_options.state_machine_options.rfc_4180.GetValue()) { result.current_errors.Insert(UNTERMINATED_QUOTES, result.cur_col_id, result.chunk_col_id, result.last_position); } @@ -1738,7 +1753,8 @@ void StringValueScanner::FinalizeChunkProcess() { result.number_of_rows++; } } - if (states.IsQuotedCurrent() && !has_unterminated_quotes) { + if (states.IsQuotedCurrent() && !has_unterminated_quotes && + state_machine->dialect_options.state_machine_options.rfc_4180.GetValue()) { // If we finish the execution of a buffer, and we end in a quoted state, it means we have unterminated // quotes result.current_errors.Insert(UNTERMINATED_QUOTES, result.cur_col_id, result.chunk_col_id, diff --git a/src/duckdb/src/execution/operator/csv_scanner/sniffer/dialect_detection.cpp b/src/duckdb/src/execution/operator/csv_scanner/sniffer/dialect_detection.cpp index 16466e3e9..5cced646d 100644 --- a/src/duckdb/src/execution/operator/csv_scanner/sniffer/dialect_detection.cpp +++ b/src/duckdb/src/execution/operator/csv_scanner/sniffer/dialect_detection.cpp @@ -51,7 +51,19 @@ string DialectCandidates::Print() { auto escape_candidate = escape_candidates_map[i]; for (idx_t j = 0; j < quote_candidate.size(); j++) { for (idx_t k = 0; k < escape_candidate.size(); k++) { - search_space << "[\'" << quote_candidate[j] << "\',\'" << escape_candidate[k] << "\']"; + search_space << "[\'"; + if (quote_candidate[j] == '\0') { + search_space << "(no quote)"; + } else { + search_space << quote_candidate[j]; + } + search_space << "\',\'"; + if (escape_candidate[k] == '\0') { + search_space << "(no escape)"; + } else { + search_space << escape_candidate[k]; + } + search_space << "\']"; if (k < escape_candidate.size() - 1) { search_space << ","; } diff --git a/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_detection.cpp b/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_detection.cpp index f701652d7..e7a5237af 100644 --- a/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_detection.cpp +++ b/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_detection.cpp @@ -296,10 +296,10 @@ void CSVSniffer::DetectDateAndTimeStampFormats(CSVStateMachine &candidate, const // check all formats and keep the first one that works StrpTimeFormat::ParseResult result; auto save_format_candidates = type_format_candidates; - bool had_format_candidates = !save_format_candidates.empty(); - bool initial_format_candidates = + const bool had_format_candidates = !save_format_candidates.empty(); + const bool initial_format_candidates = save_format_candidates.size() == original_format_candidates.at(sql_type.id()).format.size(); - bool is_set_by_user = options.dialect_options.date_format.find(sql_type.id())->second.IsSetByUser(); + const bool is_set_by_user = options.dialect_options.date_format.find(sql_type.id())->second.IsSetByUser(); while (!type_format_candidates.empty() && !is_set_by_user) { // avoid using exceptions for flow control... auto ¤t_format = candidate.dialect_options.date_format[sql_type.id()].GetValue(); @@ -371,7 +371,9 @@ void CSVSniffer::SniffTypes(DataChunk &data_chunk, CSVStateMachine &state_machin break; } - if (row_idx != start_idx_detection && cur_top_candidate == LogicalType::BOOLEAN) { + if (row_idx != start_idx_detection && + (cur_top_candidate == LogicalType::BOOLEAN || cur_top_candidate == LogicalType::DATE || + cur_top_candidate == LogicalType::TIME || cur_top_candidate == LogicalType::TIMESTAMP)) { // If we thought this was a boolean value (i.e., T,F, True, False) and it is not, we // immediately pop to varchar. while (col_type_candidates.back() != LogicalType::VARCHAR) { diff --git a/src/duckdb/src/execution/operator/csv_scanner/state_machine/csv_state_machine_cache.cpp b/src/duckdb/src/execution/operator/csv_scanner/state_machine/csv_state_machine_cache.cpp index 7b42a6d88..99d863c74 100644 --- a/src/duckdb/src/execution/operator/csv_scanner/state_machine/csv_state_machine_cache.cpp +++ b/src/duckdb/src/execution/operator/csv_scanner/state_machine/csv_state_machine_cache.cpp @@ -24,6 +24,7 @@ void CSVStateMachineCache::Insert(const CSVStateMachineOptions &state_machine_op for (uint32_t i = 0; i < StateMachine::NUM_STATES; i++) { const auto cur_state = static_cast(i); switch (cur_state) { + case CSVState::MAYBE_QUOTED: case CSVState::QUOTED: case CSVState::QUOTED_NEW_LINE: case CSVState::ESCAPE: @@ -226,12 +227,21 @@ void CSVStateMachineCache::Insert(const CSVStateMachineOptions &state_machine_op if (state_machine_options.quote == state_machine_options.escape) { transition_array[quote][static_cast(CSVState::UNQUOTED)] = CSVState::QUOTED; } - if (state_machine_options.escape == '\0' && state_machine_options.rfc_4180 == false) { - transition_array[quote][static_cast(CSVState::UNQUOTED)] = CSVState::QUOTED; + if (state_machine_options.rfc_4180 == false) { + if (escape == '\0') { + // If escape is defined, it limits a bit how relaxed quotes can be in a reliable way. + transition_array[quote][static_cast(CSVState::UNQUOTED)] = CSVState::MAYBE_QUOTED; + } else { + transition_array[quote][static_cast(CSVState::UNQUOTED)] = CSVState::QUOTED; + } } if (comment != '\0') { transition_array[comment][static_cast(CSVState::UNQUOTED)] = CSVState::COMMENT; } + if (delimiter_first_byte != ' ' && quote != ' ' && escape != ' ' && comment != ' ') { + // If space is not a special character, we can safely ignore it in an unquoted state + transition_array[' '][static_cast(CSVState::UNQUOTED)] = CSVState::UNQUOTED; + } // 8) Not Set if (multi_byte_delimiter) { @@ -314,7 +324,7 @@ void CSVStateMachineCache::Insert(const CSVStateMachineOptions &state_machine_op } // 13) Escaped Return State - if (enable_unquoted_escape && new_line_id == NewLineIdentifier::CARRY_ON) { + if (enable_unquoted_escape) { // The new state is STANDARD for \r + \n and \r + ordinary character. // Other special characters need to be handled. transition_array[delimiter_first_byte][static_cast(CSVState::ESCAPED_RETURN)] = CSVState::DELIMITER; @@ -331,6 +341,25 @@ void CSVStateMachineCache::Insert(const CSVStateMachineOptions &state_machine_op transition_array[escape][static_cast(CSVState::ESCAPED_RETURN)] = CSVState::UNQUOTED_ESCAPE; } + // 14) Maybe quoted + transition_array[quote][static_cast(CSVState::MAYBE_QUOTED)] = CSVState::MAYBE_QUOTED; + + transition_array[static_cast('\n')][static_cast(CSVState::MAYBE_QUOTED)] = + CSVState::RECORD_SEPARATOR; + if (new_line_id == NewLineIdentifier::CARRY_ON) { + transition_array[static_cast('\r')][static_cast(CSVState::MAYBE_QUOTED)] = + CSVState::CARRIAGE_RETURN; + } else { + transition_array[static_cast('\r')][static_cast(CSVState::MAYBE_QUOTED)] = + CSVState::RECORD_SEPARATOR; + } + if (multi_byte_delimiter) { + transition_array[delimiter_first_byte][static_cast(CSVState::MAYBE_QUOTED)] = + CSVState::DELIMITER_FIRST_BYTE; + } else { + transition_array[delimiter_first_byte][static_cast(CSVState::MAYBE_QUOTED)] = CSVState::DELIMITER; + } + // Initialize characters we can skip during processing, for Standard and Quoted states for (idx_t i = 0; i < StateMachine::NUM_TRANSITIONS; i++) { transition_array.skip_standard[i] = true; diff --git a/src/duckdb/src/execution/operator/csv_scanner/table_function/csv_file_scanner.cpp b/src/duckdb/src/execution/operator/csv_scanner/table_function/csv_file_scanner.cpp index efcd73f61..093e698d0 100644 --- a/src/duckdb/src/execution/operator/csv_scanner/table_function/csv_file_scanner.cpp +++ b/src/duckdb/src/execution/operator/csv_scanner/table_function/csv_file_scanner.cpp @@ -159,7 +159,8 @@ CSVFileScan::CSVFileScan(ClientContext &context, const string &file_name, const // Sniff it (We only really care about dialect detection, if types or number of columns are different this will // error out during scanning) auto &state_machine_cache = CSVStateMachineCache::Get(context); - if (options.auto_detect && options.dialect_options.num_cols == 0) { + // We sniff file if it has not been sniffed yet and either auto-detect is on, or union by name is on + if ((options.auto_detect || options.file_options.union_by_name) && options.dialect_options.num_cols == 0) { CSVSniffer sniffer(options, buffer_manager, state_machine_cache); auto sniffer_result = sniffer.SniffCSV(); if (names.empty()) { diff --git a/src/duckdb/src/function/aggregate/sorted_aggregate_function.cpp b/src/duckdb/src/function/aggregate/sorted_aggregate_function.cpp index 87960adb8..749a3fe36 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 { arg_types.emplace_back(child->return_type); ListSegmentFunctions funcs; GetSegmentDataFunctions(funcs, arg_types.back()); - arg_funcs.emplace_back(funcs); + arg_funcs.emplace_back(std::move(funcs)); } auto &order_bys = *expr.order_bys; sort_types.reserve(order_bys.orders.size()); @@ -34,7 +34,7 @@ struct SortedAggregateBindData : public FunctionData { sort_types.emplace_back(order.expression->return_type); ListSegmentFunctions funcs; GetSegmentDataFunctions(funcs, sort_types.back()); - sort_funcs.emplace_back(funcs); + sort_funcs.emplace_back(std::move(funcs)); } sorted_on_args = (children.size() == order_bys.orders.size()); for (size_t i = 0; sorted_on_args && i < children.size(); ++i) { diff --git a/src/duckdb/src/function/function.cpp b/src/duckdb/src/function/function.cpp index 2a2f32ddf..3307d3c54 100644 --- a/src/duckdb/src/function/function.cpp +++ b/src/duckdb/src/function/function.cpp @@ -74,9 +74,9 @@ bool SimpleNamedParameterFunction::HasNamedParameters() const { BaseScalarFunction::BaseScalarFunction(string name_p, vector arguments_p, LogicalType return_type_p, FunctionStability stability, LogicalType varargs_p, - FunctionNullHandling null_handling) + FunctionNullHandling null_handling, FunctionErrors errors) : SimpleFunction(std::move(name_p), std::move(arguments_p), std::move(varargs_p)), - return_type(std::move(return_type_p)), stability(stability), null_handling(null_handling), + return_type(std::move(return_type_p)), stability(stability), null_handling(null_handling), errors(errors), collation_handling(FunctionCollationHandling::PROPAGATE_COLLATIONS) { } diff --git a/src/duckdb/src/function/scalar/date/strftime.cpp b/src/duckdb/src/function/scalar/date/strftime.cpp index 1671ff54c..32222f191 100644 --- a/src/duckdb/src/function/scalar/date/strftime.cpp +++ b/src/duckdb/src/function/scalar/date/strftime.cpp @@ -302,10 +302,12 @@ ScalarFunctionSet StrpTimeFun::GetFunctions() { auto fun = ScalarFunction({LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::TIMESTAMP, StrpTimeFunction::Parse, StrpTimeFunction::Bind); fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING; + BaseScalarFunction::SetReturnsError(fun); strptime.AddFunction(fun); fun = ScalarFunction({LogicalType::VARCHAR, list_type}, LogicalType::TIMESTAMP, StrpTimeFunction::Parse, StrpTimeFunction::Bind); + BaseScalarFunction::SetReturnsError(fun); fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING; strptime.AddFunction(fun); return strptime; diff --git a/src/duckdb/src/function/scalar/generic/error.cpp b/src/duckdb/src/function/scalar/generic/error.cpp index 7563b75a6..2d42cfced 100644 --- a/src/duckdb/src/function/scalar/generic/error.cpp +++ b/src/duckdb/src/function/scalar/generic/error.cpp @@ -16,6 +16,7 @@ ScalarFunction ErrorFun::GetFunction() { ScalarFunction::UnaryFunction); // Set the function with side effects to avoid the optimization. fun.stability = FunctionStability::VOLATILE; + BaseScalarFunction::SetReturnsError(fun); return fun; } diff --git a/src/duckdb/src/function/scalar/list/list_extract.cpp b/src/duckdb/src/function/scalar/list/list_extract.cpp index 55017f5cb..058ce5f42 100644 --- a/src/duckdb/src/function/scalar/list/list_extract.cpp +++ b/src/duckdb/src/function/scalar/list/list_extract.cpp @@ -164,7 +164,8 @@ ScalarFunctionSet ListExtractFun::GetFunctions() { ListExtractFunction, ListExtractBind, nullptr, ListExtractStats); ScalarFunction sfun({LogicalType::VARCHAR, LogicalType::BIGINT}, LogicalType::VARCHAR, ListExtractFunction); - + BaseScalarFunction::SetReturnsError(lfun); + BaseScalarFunction::SetReturnsError(sfun); list_extract_set.AddFunction(lfun); list_extract_set.AddFunction(sfun); return list_extract_set; diff --git a/src/duckdb/src/function/scalar/list/list_resize.cpp b/src/duckdb/src/function/scalar/list/list_resize.cpp index dc20d00b9..019dfcc72 100644 --- a/src/duckdb/src/function/scalar/list/list_resize.cpp +++ b/src/duckdb/src/function/scalar/list/list_resize.cpp @@ -159,11 +159,11 @@ ScalarFunctionSet ListResizeFun::GetFunctions() { ScalarFunction simple_fun({LogicalType::LIST(LogicalTypeId::ANY), LogicalTypeId::ANY}, LogicalType::LIST(LogicalTypeId::ANY), ListResizeFunction, ListResizeBind); simple_fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING; - + BaseScalarFunction::SetReturnsError(simple_fun); ScalarFunction default_value_fun({LogicalType::LIST(LogicalTypeId::ANY), LogicalTypeId::ANY, LogicalTypeId::ANY}, LogicalType::LIST(LogicalTypeId::ANY), ListResizeFunction, ListResizeBind); default_value_fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING; - + BaseScalarFunction::SetReturnsError(default_value_fun); ScalarFunctionSet list_resize_set("list_resize"); list_resize_set.AddFunction(simple_fun); list_resize_set.AddFunction(default_value_fun); diff --git a/src/duckdb/src/function/scalar/operator/arithmetic.cpp b/src/duckdb/src/function/scalar/operator/arithmetic.cpp index cc5905918..a3c11ed63 100644 --- a/src/duckdb/src/function/scalar/operator/arithmetic.cpp +++ b/src/duckdb/src/function/scalar/operator/arithmetic.cpp @@ -313,81 +313,119 @@ ScalarFunction AddFunction::GetFunction(const LogicalType &left_type, const Logi if (left_type.id() == LogicalTypeId::DECIMAL) { auto function = ScalarFunction("+", {left_type, right_type}, left_type, nullptr, BindDecimalAddSubtract); + BaseScalarFunction::SetReturnsError(function); function.serialize = SerializeDecimalArithmetic; function.deserialize = DeserializeDecimalArithmetic; return function; } else if (left_type.IsIntegral()) { - return ScalarFunction("+", {left_type, right_type}, left_type, - GetScalarIntegerFunction(left_type.InternalType()), nullptr, - nullptr, PropagateNumericStats); + ScalarFunction function("+", {left_type, right_type}, left_type, + GetScalarIntegerFunction(left_type.InternalType()), + nullptr, nullptr, + PropagateNumericStats); + BaseScalarFunction::SetReturnsError(function); + return function; } else { - return ScalarFunction("+", {left_type, right_type}, left_type, - GetScalarBinaryFunction(left_type.InternalType())); + ScalarFunction function("+", {left_type, right_type}, left_type, + GetScalarBinaryFunction(left_type.InternalType())); + BaseScalarFunction::SetReturnsError(function); + return function; } } switch (left_type.id()) { case LogicalTypeId::DATE: if (right_type.id() == LogicalTypeId::INTEGER) { - return ScalarFunction("+", {left_type, right_type}, LogicalType::DATE, - ScalarFunction::BinaryFunction); + ScalarFunction function("+", {left_type, right_type}, LogicalType::DATE, + ScalarFunction::BinaryFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } else if (right_type.id() == LogicalTypeId::INTERVAL) { - return ScalarFunction("+", {left_type, right_type}, LogicalType::TIMESTAMP, - ScalarFunction::BinaryFunction); + ScalarFunction function("+", {left_type, right_type}, LogicalType::TIMESTAMP, + ScalarFunction::BinaryFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } else if (right_type.id() == LogicalTypeId::TIME) { - return ScalarFunction("+", {left_type, right_type}, LogicalType::TIMESTAMP, - ScalarFunction::BinaryFunction); + ScalarFunction function("+", {left_type, right_type}, LogicalType::TIMESTAMP, + ScalarFunction::BinaryFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } else if (right_type.id() == LogicalTypeId::TIME_TZ) { - return ScalarFunction("+", {left_type, right_type}, LogicalType::TIMESTAMP_TZ, - ScalarFunction::BinaryFunction); + ScalarFunction function("+", {left_type, right_type}, LogicalType::TIMESTAMP_TZ, + ScalarFunction::BinaryFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } break; case LogicalTypeId::INTEGER: if (right_type.id() == LogicalTypeId::DATE) { - return ScalarFunction("+", {left_type, right_type}, right_type, - ScalarFunction::BinaryFunction); + ScalarFunction function("+", {left_type, right_type}, right_type, + ScalarFunction::BinaryFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } break; case LogicalTypeId::INTERVAL: if (right_type.id() == LogicalTypeId::INTERVAL) { - return ScalarFunction("+", {left_type, right_type}, LogicalType::INTERVAL, - ScalarFunction::BinaryFunction); + ScalarFunction function("+", {left_type, right_type}, LogicalType::INTERVAL, + ScalarFunction::BinaryFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } else if (right_type.id() == LogicalTypeId::DATE) { - return ScalarFunction("+", {left_type, right_type}, LogicalType::TIMESTAMP, - ScalarFunction::BinaryFunction); + ScalarFunction function("+", {left_type, right_type}, LogicalType::TIMESTAMP, + ScalarFunction::BinaryFunction); + BaseScalarFunction::SetReturnsError(function); + return function; } else if (right_type.id() == LogicalTypeId::TIME) { - return ScalarFunction("+", {left_type, right_type}, LogicalType::TIME, - ScalarFunction::BinaryFunction); + ScalarFunction function("+", {left_type, right_type}, LogicalType::TIME, + ScalarFunction::BinaryFunction); + ScalarFunction::SetReturnsError(function); + return function; } else if (right_type.id() == LogicalTypeId::TIME_TZ) { - return ScalarFunction("+", {left_type, right_type}, LogicalType::TIME_TZ, - ScalarFunction::BinaryFunction); + ScalarFunction function( + "+", {left_type, right_type}, LogicalType::TIME_TZ, + ScalarFunction::BinaryFunction); + ScalarFunction::SetReturnsError(function); + return function; } else if (right_type.id() == LogicalTypeId::TIMESTAMP) { - return ScalarFunction("+", {left_type, right_type}, LogicalType::TIMESTAMP, - ScalarFunction::BinaryFunction); + ScalarFunction function("+", {left_type, right_type}, LogicalType::TIMESTAMP, + ScalarFunction::BinaryFunction); + ScalarFunction::SetReturnsError(function); + return function; } break; case LogicalTypeId::TIME: if (right_type.id() == LogicalTypeId::INTERVAL) { - return ScalarFunction("+", {left_type, right_type}, LogicalType::TIME, - ScalarFunction::BinaryFunction); + ScalarFunction function("+", {left_type, right_type}, LogicalType::TIME, + ScalarFunction::BinaryFunction); + ScalarFunction::SetReturnsError(function); + return function; } else if (right_type.id() == LogicalTypeId::DATE) { - return ScalarFunction("+", {left_type, right_type}, LogicalType::TIMESTAMP, - ScalarFunction::BinaryFunction); + ScalarFunction function("+", {left_type, right_type}, LogicalType::TIMESTAMP, + ScalarFunction::BinaryFunction); + ScalarFunction::SetReturnsError(function); + return function; } break; case LogicalTypeId::TIME_TZ: if (right_type.id() == LogicalTypeId::DATE) { - return ScalarFunction("+", {left_type, right_type}, LogicalType::TIMESTAMP_TZ, - ScalarFunction::BinaryFunction); + ScalarFunction function("+", {left_type, right_type}, LogicalType::TIMESTAMP_TZ, + ScalarFunction::BinaryFunction); + ScalarFunction::SetReturnsError(function); + return function; } else if (right_type.id() == LogicalTypeId::INTERVAL) { - return ScalarFunction("+", {left_type, right_type}, LogicalType::TIME_TZ, - ScalarFunction::BinaryFunction); + ScalarFunction function( + "+", {left_type, right_type}, LogicalType::TIME_TZ, + ScalarFunction::BinaryFunction); + ScalarFunction::SetReturnsError(function); + return function; } break; case LogicalTypeId::TIMESTAMP: if (right_type.id() == LogicalTypeId::INTERVAL) { - return ScalarFunction("+", {left_type, right_type}, LogicalType::TIMESTAMP, - ScalarFunction::BinaryFunction); + ScalarFunction function("+", {left_type, right_type}, LogicalType::TIMESTAMP, + ScalarFunction::BinaryFunction); + ScalarFunction::SetReturnsError(function); + return function; } break; default: @@ -578,79 +616,105 @@ static unique_ptr NegateBindStatistics(ClientContext &context, F ScalarFunction SubtractFunction::GetFunction(const LogicalType &type) { if (type.id() == LogicalTypeId::INTERVAL) { - return ScalarFunction("-", {type}, type, ScalarFunction::UnaryFunction); + ScalarFunction func("-", {type}, type, ScalarFunction::UnaryFunction); + ScalarFunction::SetReturnsError(func); + return func; } else if (type.id() == LogicalTypeId::DECIMAL) { - return ScalarFunction("-", {type}, type, nullptr, DecimalNegateBind, nullptr, NegateBindStatistics); + ScalarFunction func("-", {type}, type, nullptr, DecimalNegateBind, nullptr, NegateBindStatistics); + return func; } else { D_ASSERT(type.IsNumeric()); - return ScalarFunction("-", {type}, type, ScalarFunction::GetScalarUnaryFunction(type), nullptr, - nullptr, NegateBindStatistics); + ScalarFunction func("-", {type}, type, ScalarFunction::GetScalarUnaryFunction(type), nullptr, + nullptr, NegateBindStatistics); + ScalarFunction::SetReturnsError(func); + return func; } } ScalarFunction SubtractFunction::GetFunction(const LogicalType &left_type, const LogicalType &right_type) { if (left_type.IsNumeric() && left_type.id() == right_type.id()) { if (left_type.id() == LogicalTypeId::DECIMAL) { - auto function = - ScalarFunction("-", {left_type, right_type}, left_type, nullptr, - BindDecimalAddSubtract); + ScalarFunction function("-", {left_type, right_type}, left_type, nullptr, + BindDecimalAddSubtract); + ScalarFunction::SetReturnsError(function); function.serialize = SerializeDecimalArithmetic; function.deserialize = DeserializeDecimalArithmetic; return function; } else if (left_type.IsIntegral()) { - return ScalarFunction( + ScalarFunction function( "-", {left_type, right_type}, left_type, GetScalarIntegerFunction(left_type.InternalType()), nullptr, nullptr, PropagateNumericStats); + ScalarFunction::SetReturnsError(function); + return function; } else { - return ScalarFunction("-", {left_type, right_type}, left_type, - GetScalarBinaryFunction(left_type.InternalType())); + ScalarFunction function("-", {left_type, right_type}, left_type, + GetScalarBinaryFunction(left_type.InternalType())); + ScalarFunction::SetReturnsError(function); + return function; } } switch (left_type.id()) { case LogicalTypeId::DATE: if (right_type.id() == LogicalTypeId::DATE) { - return ScalarFunction("-", {left_type, right_type}, LogicalType::BIGINT, - ScalarFunction::BinaryFunction); + ScalarFunction function("-", {left_type, right_type}, LogicalType::BIGINT, + ScalarFunction::BinaryFunction); + ScalarFunction::SetReturnsError(function); + return function; } else if (right_type.id() == LogicalTypeId::INTEGER) { - return ScalarFunction("-", {left_type, right_type}, LogicalType::DATE, - ScalarFunction::BinaryFunction); + ScalarFunction function("-", {left_type, right_type}, LogicalType::DATE, + ScalarFunction::BinaryFunction); + ScalarFunction::SetReturnsError(function); + return function; } else if (right_type.id() == LogicalTypeId::INTERVAL) { - return ScalarFunction("-", {left_type, right_type}, LogicalType::TIMESTAMP, - ScalarFunction::BinaryFunction); + ScalarFunction function("-", {left_type, right_type}, LogicalType::TIMESTAMP, + ScalarFunction::BinaryFunction); + ScalarFunction::SetReturnsError(function); + return function; } break; case LogicalTypeId::TIMESTAMP: if (right_type.id() == LogicalTypeId::TIMESTAMP) { - return ScalarFunction( + ScalarFunction function( "-", {left_type, right_type}, LogicalType::INTERVAL, ScalarFunction::BinaryFunction); + ScalarFunction::SetReturnsError(function); + return function; } else if (right_type.id() == LogicalTypeId::INTERVAL) { - return ScalarFunction( + ScalarFunction function( "-", {left_type, right_type}, LogicalType::TIMESTAMP, ScalarFunction::BinaryFunction); + ScalarFunction::SetReturnsError(function); + return function; } break; case LogicalTypeId::INTERVAL: if (right_type.id() == LogicalTypeId::INTERVAL) { - return ScalarFunction("-", {left_type, right_type}, LogicalType::INTERVAL, - ScalarFunction::BinaryFunction); + ScalarFunction function( + "-", {left_type, right_type}, LogicalType::INTERVAL, + ScalarFunction::BinaryFunction); + ScalarFunction::SetReturnsError(function); + return function; } break; case LogicalTypeId::TIME: if (right_type.id() == LogicalTypeId::INTERVAL) { - return ScalarFunction("-", {left_type, right_type}, LogicalType::TIME, - ScalarFunction::BinaryFunction); + ScalarFunction function("-", {left_type, right_type}, LogicalType::TIME, + ScalarFunction::BinaryFunction); + ScalarFunction::SetReturnsError(function); + return function; } break; case LogicalTypeId::TIME_TZ: if (right_type.id() == LogicalTypeId::INTERVAL) { - return ScalarFunction( + ScalarFunction function( "-", {left_type, right_type}, LogicalType::TIME_TZ, ScalarFunction::BinaryFunction); + ScalarFunction::SetReturnsError(function); + return function; } break; default: @@ -823,6 +887,9 @@ ScalarFunctionSet OperatorMultiplyFun::GetFunctions() { multiply.AddFunction( ScalarFunction({LogicalType::BIGINT, LogicalType::INTERVAL}, LogicalType::INTERVAL, ScalarFunction::BinaryFunction)); + for (auto &func : multiply.functions) { + ScalarFunction::SetReturnsError(func); + } return multiply; } @@ -968,6 +1035,9 @@ ScalarFunctionSet OperatorFloatDivideFun::GetFunctions() { fp_divide.AddFunction( ScalarFunction({LogicalType::INTERVAL, LogicalType::BIGINT}, LogicalType::INTERVAL, BinaryScalarFunctionIgnoreZero)); + for (auto &func : fp_divide.functions) { + ScalarFunction::SetReturnsError(func); + } return fp_divide; } @@ -981,6 +1051,9 @@ ScalarFunctionSet OperatorIntegerDivideFun::GetFunctions() { ScalarFunction({type, type}, type, GetBinaryFunctionIgnoreZero(type.InternalType()))); } } + for (auto &func : full_divide.functions) { + ScalarFunction::SetReturnsError(func); + } return full_divide; } @@ -1036,6 +1109,10 @@ ScalarFunctionSet OperatorModuloFun::GetFunctions() { ScalarFunction({type, type}, type, GetBinaryFunctionIgnoreZero(type.InternalType()))); } } + for (auto &func : modulo.functions) { + ScalarFunction::SetReturnsError(func); + } + return modulo; } diff --git a/src/duckdb/src/function/scalar/sequence/nextval.cpp b/src/duckdb/src/function/scalar/sequence/nextval.cpp index b5ae85c86..7e19dae7d 100644 --- a/src/duckdb/src/function/scalar/sequence/nextval.cpp +++ b/src/duckdb/src/function/scalar/sequence/nextval.cpp @@ -140,6 +140,7 @@ ScalarFunction NextvalFun::GetFunction() { next_val.deserialize = Deserialize; next_val.get_modified_databases = NextValModifiedDatabases; next_val.init_local_state = NextValLocalFunction; + BaseScalarFunction::SetReturnsError(next_val); return next_val; } @@ -151,6 +152,7 @@ ScalarFunction CurrvalFun::GetFunction() { curr_val.serialize = Serialize; curr_val.deserialize = Deserialize; curr_val.init_local_state = NextValLocalFunction; + BaseScalarFunction::SetReturnsError(curr_val); return curr_val; } diff --git a/src/duckdb/src/function/scalar/string/length.cpp b/src/duckdb/src/function/scalar/string/length.cpp index b757596e2..f2ec8bae1 100644 --- a/src/duckdb/src/function/scalar/string/length.cpp +++ b/src/duckdb/src/function/scalar/string/length.cpp @@ -241,6 +241,9 @@ ScalarFunctionSet ArrayLengthFun::GetFunctions() { ScalarFunction({LogicalType::LIST(LogicalType::ANY)}, LogicalType::BIGINT, nullptr, ArrayOrListLengthBind)); array_length.AddFunction(ScalarFunction({LogicalType::LIST(LogicalType::ANY), LogicalType::BIGINT}, LogicalType::BIGINT, nullptr, ArrayOrListLengthBinaryBind)); + for (auto &func : array_length.functions) { + BaseScalarFunction::SetReturnsError(func); + } return (array_length); } diff --git a/src/duckdb/src/function/scalar/string/regexp.cpp b/src/duckdb/src/function/scalar/string/regexp.cpp index 201181327..2383e3b57 100644 --- a/src/duckdb/src/function/scalar/string/regexp.cpp +++ b/src/duckdb/src/function/scalar/string/regexp.cpp @@ -405,6 +405,9 @@ ScalarFunctionSet RegexpMatchesFun::GetFunctions() { {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BOOLEAN, RegexpMatchesFunction, RegexpMatchesBind, nullptr, nullptr, RegexInitLocalState, LogicalType::INVALID, FunctionStability::CONSISTENT, FunctionNullHandling::SPECIAL_HANDLING)); + for (auto &func : regexp_partial_match.functions) { + BaseScalarFunction::SetReturnsError(func); + } return (regexp_partial_match); } diff --git a/src/duckdb/src/function/table/read_csv.cpp b/src/duckdb/src/function/table/read_csv.cpp index b999573ae..f01934e7b 100644 --- a/src/duckdb/src/function/table/read_csv.cpp +++ b/src/duckdb/src/function/table/read_csv.cpp @@ -74,7 +74,7 @@ void SchemaDiscovery(ClientContext &context, ReadCSVData &result, CSVReaderOptio } // We do a copy of the options to not pollute the options of the first file. - const idx_t max_files_to_sniff = 10; + constexpr idx_t max_files_to_sniff = 10; idx_t files_to_sniff = file_paths.size() > max_files_to_sniff ? max_files_to_sniff : file_paths.size(); while (total_number_of_rows < required_number_of_lines && current_file + 1 < files_to_sniff) { auto option_copy = option_og; @@ -124,8 +124,8 @@ static unique_ptr ReadCSVBind(ClientContext &context, TableFunctio auto result = make_uniq(); auto &options = result->options; - auto multi_file_reader = MultiFileReader::Create(input.table_function); - auto multi_file_list = multi_file_reader->CreateFileList(context, input.inputs[0]); + const auto multi_file_reader = MultiFileReader::Create(input.table_function); + const auto multi_file_list = multi_file_reader->CreateFileList(context, input.inputs[0]); if (multi_file_list->GetTotalFileCount() > 1) { options.multi_file_reader = true; } @@ -133,23 +133,25 @@ static unique_ptr ReadCSVBind(ClientContext &context, TableFunctio options.file_options.AutoDetectHivePartitioning(*multi_file_list, context); options.Verify(); - if (!options.auto_detect) { - if (!options.columns_set) { - throw BinderException("read_csv requires columns to be specified through the 'columns' option. Use " - "read_csv_auto or set read_csv(..., " - "AUTO_DETECT=TRUE) to automatically guess columns."); + if (!options.file_options.union_by_name) { + if (options.auto_detect) { + SchemaDiscovery(context, *result, options, return_types, names, *multi_file_list); } else { + // If we are not running the sniffer, the columns must be set! + if (!options.columns_set) { + throw BinderException("read_csv requires columns to be specified through the 'columns' option. Use " + "read_csv_auto or set read_csv(..., " + "AUTO_DETECT=TRUE) to automatically guess columns."); + } names = options.name_list; return_types = options.sql_type_list; } - } - if (options.auto_detect && !options.file_options.union_by_name) { - SchemaDiscovery(context, *result, options, return_types, names, *multi_file_list); - } + D_ASSERT(return_types.size() == names.size()); + result->options.dialect_options.num_cols = names.size(); - D_ASSERT(return_types.size() == names.size()); - result->options.dialect_options.num_cols = names.size(); - if (options.file_options.union_by_name) { + multi_file_reader->BindOptions(options.file_options, *multi_file_list, return_types, names, + result->reader_bind); + } else { result->reader_bind = multi_file_reader->BindUnionReader(context, return_types, names, *multi_file_list, *result, options); if (result->union_readers.size() > 1) { @@ -158,7 +160,7 @@ static unique_ptr ReadCSVBind(ClientContext &context, TableFunctio } } if (!options.sql_types_per_column.empty()) { - auto exception = CSVError::ColumnTypesError(options.sql_types_per_column, names); + const auto exception = CSVError::ColumnTypesError(options.sql_types_per_column, names); if (!exception.error_message.empty()) { throw BinderException(exception.error_message); } @@ -169,14 +171,10 @@ static unique_ptr ReadCSVBind(ClientContext &context, TableFunctio } } } - result->csv_types = return_types; - result->csv_names = names; - } else { - result->csv_types = return_types; - result->csv_names = names; - multi_file_reader->BindOptions(options.file_options, *multi_file_list, return_types, names, - result->reader_bind); } + + result->csv_types = return_types; + result->csv_names = names; result->return_types = return_types; result->return_names = names; if (!options.force_not_null_names.empty()) { @@ -203,7 +201,6 @@ static unique_ptr ReadCSVBind(ClientContext &context, TableFunctio // TODO: make the CSV reader use MultiFileList throughout, instead of converting to vector result->files = multi_file_list->GetAllFiles(); - result->Finalize(); return std::move(result); } diff --git a/src/duckdb/src/function/table/version/pragma_version.cpp b/src/duckdb/src/function/table/version/pragma_version.cpp index dd600ac7b..db89e256f 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 "4-dev3836" +#define DUCKDB_PATCH_VERSION "4-dev3921" #endif #ifndef DUCKDB_MINOR_VERSION #define DUCKDB_MINOR_VERSION 1 @@ -8,10 +8,10 @@ #define DUCKDB_MAJOR_VERSION 1 #endif #ifndef DUCKDB_VERSION -#define DUCKDB_VERSION "v1.1.4-dev3836" +#define DUCKDB_VERSION "v1.1.4-dev3921" #endif #ifndef DUCKDB_SOURCE_ID -#define DUCKDB_SOURCE_ID "ec7be6f00e" +#define DUCKDB_SOURCE_ID "6c4d2a394f" #endif #include "duckdb/function/table/system_functions.hpp" #include "duckdb/main/database.hpp" diff --git a/src/duckdb/src/function/window/window_value_function.cpp b/src/duckdb/src/function/window/window_value_function.cpp index ce776b7de..d6bd816f2 100644 --- a/src/duckdb/src/function/window/window_value_function.cpp +++ b/src/duckdb/src/function/window/window_value_function.cpp @@ -4,6 +4,7 @@ #include "duckdb/function/window/window_collection.hpp" #include "duckdb/function/window/window_index_tree.hpp" #include "duckdb/function/window/window_shared_expressions.hpp" +#include "duckdb/function/window/window_token_tree.hpp" #include "duckdb/function/window/window_value_function.hpp" #include "duckdb/planner/expression/bound_window_expression.hpp" @@ -22,7 +23,7 @@ class WindowValueGlobalState : public WindowExecutorGlobalState { child_idx(executor.child_idx) { if (!executor.arg_order_idx.empty()) { - inner_sort = make_uniq(executor.context, executor.wexpr.arg_orders, executor.arg_order_idx, + value_tree = make_uniq(executor.context, executor.wexpr.arg_orders, executor.arg_order_idx, payload_count); } } @@ -39,9 +40,11 @@ class WindowValueGlobalState : public WindowExecutorGlobalState { ValidityMask all_valid; optional_ptr ignore_nulls; + //! Copy of the executor child_idx const column_t child_idx; - unique_ptr inner_sort; + //! Merge sort tree to map unfiltered row number to value + unique_ptr value_tree; }; //===--------------------------------------------------------------------===// @@ -55,8 +58,8 @@ class WindowValueLocalState : public WindowExecutorBoundsState { : WindowExecutorBoundsState(gvstate), gvstate(gvstate) { WindowAggregatorLocalState::InitSubFrames(frames, gvstate.executor.wexpr.exclude_clause); - if (gvstate.inner_sort) { - local_sort = gvstate.inner_sort->GetLocalState(); + if (gvstate.value_tree) { + local_value = gvstate.value_tree->GetLocalState(); if (gvstate.executor.wexpr.ignore_nulls) { sort_nulls.Initialize(); } @@ -72,7 +75,7 @@ class WindowValueLocalState : public WindowExecutorBoundsState { //! The corresponding global value state const WindowValueGlobalState &gvstate; //! The optional sorting state for secondary sorts - unique_ptr local_sort; + unique_ptr local_value; //! Reusable selection vector for NULLs SelectionVector sort_nulls; //! The frame boundaries, used for EXCLUDE @@ -86,7 +89,7 @@ void WindowValueLocalState::Sink(WindowExecutorGlobalState &gstate, DataChunk &s idx_t input_idx) { WindowExecutorBoundsState::Sink(gstate, sink_chunk, coll_chunk, input_idx); - if (local_sort) { + if (local_value) { idx_t filtered = 0; optional_ptr filter_sel; @@ -106,18 +109,18 @@ void WindowValueLocalState::Sink(WindowExecutorGlobalState &gstate, DataChunk &s filter_sel = &sort_nulls; } - auto &local_index = local_sort->Cast(); - local_index.SinkChunk(sink_chunk, input_idx, filter_sel, filtered); + auto &value_state = local_value->Cast(); + value_state.SinkChunk(sink_chunk, input_idx, filter_sel, filtered); } } void WindowValueLocalState::Finalize(WindowExecutorGlobalState &gstate, CollectionPtr collection) { WindowExecutorBoundsState::Finalize(gstate, collection); - if (local_sort) { - auto &local_index = local_sort->Cast(); - local_index.Sort(); - local_index.index_tree.Build(); + if (local_value) { + auto &value_state = local_value->Cast(); + value_state.Sort(); + value_state.index_tree.Build(); } // Prepare to scan @@ -165,36 +168,155 @@ unique_ptr WindowValueExecutor::GetLocalState(const Wi return make_uniq(gvstate); } +//===--------------------------------------------------------------------===// +// WindowLeadLagGlobalState +//===--------------------------------------------------------------------===// +// The functions LEAD and LAG can be extended to a windowed version with +// two independent ORDER BY clauses just like first_value and other value +// functions. +// To evaluate a windowed LEAD/LAG, one has to (1) compute the ROW_NUMBER +// of the own row, (2) adjust the row number by adding or subtracting an +// offset, (3) find the row at that offset, and (4) evaluate the expression +// provided to LEAD/LAG on this row. One can use the algorithm from Section +// 4.4 to determine the row number of the own row (step 1) and the +// algorithm from Section 4.5 to find the row with the adjusted position +// (step 3). Both algorithms are in O(𝑛 log𝑛), so the overall algorithm +// for LEAD/LAG is also O(𝑛 log𝑛). +// +// 4.4: unique WindowTokenTree +// 4.5: WindowIndexTree + +class WindowLeadLagGlobalState : public WindowValueGlobalState { +public: + explicit WindowLeadLagGlobalState(const WindowValueExecutor &executor, const idx_t payload_count, + const ValidityMask &partition_mask, const ValidityMask &order_mask) + : WindowValueGlobalState(executor, payload_count, partition_mask, order_mask) { + + if (value_tree) { + // "The ROW_NUMBER function can be computed by disambiguating duplicate elements based on their position in + // the input data, such that two elements never compare as equal." + // Note: If the user specifies an partial secondary sort, the disambiguation will use the + // partition's row numbers, not the secondary sort's row numbers. + row_tree = make_uniq(executor.context, executor.wexpr.arg_orders, executor.arg_order_idx, + payload_count, true); + } + } + + //! Merge sort tree to map partition offset to row number (algorithm from Section 4.5) + unique_ptr row_tree; +}; + //===--------------------------------------------------------------------===// // WindowLeadLagLocalState //===--------------------------------------------------------------------===// class WindowLeadLagLocalState : public WindowValueLocalState { public: - explicit WindowLeadLagLocalState(const WindowValueGlobalState &gstate) : WindowValueLocalState(gstate) { + explicit WindowLeadLagLocalState(const WindowLeadLagGlobalState &gstate) : WindowValueLocalState(gstate) { + if (gstate.row_tree) { + local_row = gstate.row_tree->GetLocalState(); + } } + + //! Accumulate the secondary sort values + void Sink(WindowExecutorGlobalState &gstate, DataChunk &sink_chunk, DataChunk &coll_chunk, + idx_t input_idx) override; + //! Finish the sinking and prepare to scan + void Finalize(WindowExecutorGlobalState &gstate, CollectionPtr collection) override; + + //! The optional sorting state for the secondary sort row mapping + unique_ptr local_row; }; +void WindowLeadLagLocalState::Sink(WindowExecutorGlobalState &gstate, DataChunk &sink_chunk, DataChunk &coll_chunk, + idx_t input_idx) { + WindowValueLocalState::Sink(gstate, sink_chunk, coll_chunk, input_idx); + + if (local_row) { + idx_t filtered = 0; + optional_ptr filter_sel; + + auto &row_state = local_row->Cast(); + row_state.SinkChunk(sink_chunk, input_idx, filter_sel, filtered); + } +} + +void WindowLeadLagLocalState::Finalize(WindowExecutorGlobalState &gstate, CollectionPtr collection) { + WindowValueLocalState::Finalize(gstate, collection); + + if (local_row) { + auto &row_state = local_row->Cast(); + row_state.Sort(); + row_state.window_tree.Build(); + } +} + +//===--------------------------------------------------------------------===// +// WindowLeadLagExecutor +//===--------------------------------------------------------------------===// WindowLeadLagExecutor::WindowLeadLagExecutor(BoundWindowExpression &wexpr, ClientContext &context, WindowSharedExpressions &shared) : WindowValueExecutor(wexpr, context, shared) { } +unique_ptr WindowLeadLagExecutor::GetGlobalState(const idx_t payload_count, + const ValidityMask &partition_mask, + const ValidityMask &order_mask) const { + return make_uniq(*this, payload_count, partition_mask, order_mask); +} + unique_ptr WindowLeadLagExecutor::GetLocalState(const WindowExecutorGlobalState &gstate) const { - const auto &gvstate = gstate.Cast(); - return make_uniq(gvstate); + const auto &glstate = gstate.Cast(); + return make_uniq(glstate); } void WindowLeadLagExecutor::EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate, DataChunk &eval_chunk, Vector &result, idx_t count, idx_t row_idx) const { - auto &gvstate = gstate.Cast(); - auto &ignore_nulls = gvstate.ignore_nulls; + auto &glstate = gstate.Cast(); + auto &ignore_nulls = glstate.ignore_nulls; auto &llstate = lstate.Cast(); auto &cursor = *llstate.cursor; WindowInputExpression leadlag_offset(eval_chunk, offset_idx); WindowInputExpression leadlag_default(eval_chunk, default_idx); + auto partition_begin = FlatVector::GetData(llstate.bounds.data[PARTITION_BEGIN]); + auto partition_end = FlatVector::GetData(llstate.bounds.data[PARTITION_END]); + if (glstate.row_tree) { + auto &frames = llstate.frames; + frames.resize(1); + auto &frame = frames[0]; + for (idx_t i = 0; i < count; ++i, ++row_idx) { + // (1) compute the ROW_NUMBER of the own row + frame = FrameBounds(partition_begin[i], partition_end[i]); + const auto own_row = glstate.row_tree->Rank(frame.start, frame.end, row_idx) - 1; + // (2) adjust the row number by adding or subtracting an offset + auto val_idx = NumericCast(own_row); + int64_t offset = 1; + if (wexpr.offset_expr) { + offset = leadlag_offset.GetCell(i); + } + if (wexpr.GetExpressionType() == ExpressionType::WINDOW_LEAD) { + val_idx = AddOperatorOverflowCheck::Operation(val_idx, offset); + } else { + val_idx = SubtractOperatorOverflowCheck::Operation(val_idx, offset); + } + const auto frame_width = NumericCast(frame.end - frame.start); + if (val_idx >= 0 && val_idx < frame_width) { + // (3) find the row at that offset + const auto n = NumericCast(val_idx); + const auto nth_index = glstate.value_tree->SelectNth(frames, n); + // (4) evaluate the expression provided to LEAD/LAG on this row. + cursor.CopyCell(0, nth_index, result, i); + } else if (wexpr.default_expr) { + leadlag_default.CopyCell(result, i); + } else { + FlatVector::SetNull(result, i, true); + } + } + return; + } + bool can_shift = ignore_nulls->AllValid(); if (wexpr.offset_expr) { can_shift = can_shift && wexpr.offset_expr->IsFoldable(); @@ -203,8 +325,6 @@ void WindowLeadLagExecutor::EvaluateInternal(WindowExecutorGlobalState &gstate, can_shift = can_shift && wexpr.default_expr->IsFoldable(); } - auto partition_begin = FlatVector::GetData(llstate.bounds.data[PARTITION_BEGIN]); - auto partition_end = FlatVector::GetData(llstate.bounds.data[PARTITION_END]); const auto row_end = row_idx + count; for (idx_t i = 0; i < count;) { int64_t offset = 1; @@ -289,14 +409,14 @@ void WindowFirstValueExecutor::EvaluateInternal(WindowExecutorGlobalState &gstat auto &ignore_nulls = *gvstate.ignore_nulls; auto exclude_mode = gvstate.executor.wexpr.exclude_clause; WindowAggregator::EvaluateSubFrames(bounds, exclude_mode, count, row_idx, frames, [&](idx_t i) { - if (gvstate.inner_sort) { + if (gvstate.value_tree) { idx_t frame_width = 0; for (const auto &frame : frames) { frame_width += frame.end - frame.start; } if (frame_width) { - const auto first_idx = gvstate.inner_sort->SelectNth(frames, 0); + const auto first_idx = gvstate.value_tree->SelectNth(frames, 0); cursor.CopyCell(0, first_idx, result, i); } else { FlatVector::SetNull(result, i, true); @@ -339,14 +459,14 @@ void WindowLastValueExecutor::EvaluateInternal(WindowExecutorGlobalState &gstate auto &ignore_nulls = *gvstate.ignore_nulls; auto exclude_mode = gvstate.executor.wexpr.exclude_clause; WindowAggregator::EvaluateSubFrames(bounds, exclude_mode, count, row_idx, frames, [&](idx_t i) { - if (gvstate.inner_sort) { + if (gvstate.value_tree) { idx_t frame_width = 0; for (const auto &frame : frames) { frame_width += frame.end - frame.start; } if (frame_width) { - const auto last_idx = gvstate.inner_sort->SelectNth(frames, frame_width - 1); + const auto last_idx = gvstate.value_tree->SelectNth(frames, frame_width - 1); cursor.CopyCell(0, last_idx, result, i); } else { FlatVector::SetNull(result, i, true); @@ -405,14 +525,14 @@ void WindowNthValueExecutor::EvaluateInternal(WindowExecutorGlobalState &gstate, // Decrement as we go along. auto n = idx_t(n_param); - if (gvstate.inner_sort) { + if (gvstate.value_tree) { idx_t frame_width = 0; for (const auto &frame : frames) { frame_width += frame.end - frame.start; } if (n < frame_width) { - const auto nth_index = gvstate.inner_sort->SelectNth(frames, n - 1); + const auto nth_index = gvstate.value_tree->SelectNth(frames, n - 1); cursor.CopyCell(0, nth_index, result, i); } else { FlatVector::SetNull(result, i, true); diff --git a/src/duckdb/src/include/duckdb/common/enums/function_errors.hpp b/src/duckdb/src/include/duckdb/common/enums/function_errors.hpp index 5f00c55a1..3d37c53e0 100644 --- a/src/duckdb/src/include/duckdb/common/enums/function_errors.hpp +++ b/src/duckdb/src/include/duckdb/common/enums/function_errors.hpp @@ -13,6 +13,6 @@ namespace duckdb { //! Whether or not a function can throw an error or not -enum class FunctionErrors : uint8_t { CANNOT_ERROR = 0, CAN_THROW_ERROR = 1 }; +enum class FunctionErrors : uint8_t { CANNOT_ERROR = 0, CAN_THROW_RUNTIME_ERROR = 1 }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/common/platform.hpp b/src/duckdb/src/include/duckdb/common/platform.hpp index 94eea304d..cba08883f 100644 --- a/src/duckdb/src/include/duckdb/common/platform.hpp +++ b/src/duckdb/src/include/duckdb/common/platform.hpp @@ -1,3 +1,12 @@ +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/common/platform.hpp +// +// +//===----------------------------------------------------------------------===// + +#pragma once #include // duplicated from string_util.h to avoid linking issues @@ -6,6 +15,23 @@ #define DUCKDB_QUOTE_DEFINE(x) DUCKDB_QUOTE_DEFINE_IMPL(x) #endif +#if defined(_WIN32) || defined(__APPLE__) || defined(__FreeBSD__) +#else +#if !defined(_GNU_SOURCE) +#define _GNU_SOURCE +#include +#ifndef __USE_GNU +#define __MUSL__ +#endif +#undef _GNU_SOURCE /* don't contaminate other includes unnecessarily */ +#else +#include +#ifndef __USE_GNU +#define __MUSL__ +#endif +#endif +#endif + namespace duckdb { std::string DuckDBPlatform() { // NOLINT: allow definition in header @@ -37,11 +63,16 @@ std::string DuckDBPlatform() { // NOLINT: allow definition in header arch = "arm64"; #endif -#if !defined(_GLIBCXX_USE_CXX11_ABI) || _GLIBCXX_USE_CXX11_ABI == 0 +#if defined(__MUSL__) + if (os == "linux") { + postfix = "_musl"; + } +#elif !defined(_GLIBCXX_USE_CXX11_ABI) || _GLIBCXX_USE_CXX11_ABI == 0 if (os == "linux") { postfix = "_gcc4"; } #endif + #if defined(__ANDROID__) postfix += "_android"; // using + because it may also be gcc4 #endif diff --git a/src/duckdb/src/include/duckdb/common/vector_operations/unary_executor.hpp b/src/duckdb/src/include/duckdb/common/vector_operations/unary_executor.hpp index 85365122a..1a31822ff 100644 --- a/src/duckdb/src/include/duckdb/common/vector_operations/unary_executor.hpp +++ b/src/duckdb/src/include/duckdb/common/vector_operations/unary_executor.hpp @@ -141,7 +141,7 @@ struct UnaryExecutor { template static inline void ExecuteStandard(Vector &input, Vector &result, idx_t count, void *dataptr, bool adds_nulls, - FunctionErrors errors = FunctionErrors::CAN_THROW_ERROR) { + FunctionErrors errors = FunctionErrors::CAN_THROW_RUNTIME_ERROR) { switch (input.GetVectorType()) { case VectorType::CONSTANT_VECTOR: { result.SetVectorType(VectorType::CONSTANT_VECTOR); @@ -219,7 +219,7 @@ struct UnaryExecutor { template > static void Execute(Vector &input, Vector &result, idx_t count, FUNC fun, - FunctionErrors errors = FunctionErrors::CAN_THROW_ERROR) { + FunctionErrors errors = FunctionErrors::CAN_THROW_RUNTIME_ERROR) { ExecuteStandard( input, result, count, reinterpret_cast(&fun), false, errors); } diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/base_scanner.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/base_scanner.hpp index 53d964eef..93b8bf9ac 100644 --- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/base_scanner.hpp +++ b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/base_scanner.hpp @@ -30,6 +30,11 @@ class ScannerResult { } static inline void SetUnquoted(ScannerResult &result) { + if (result.states.states[0] == CSVState::UNQUOTED && result.states.states[1] == CSVState::UNQUOTED && + result.state_machine.dialect_options.state_machine_options.escape != '\0') { + // This means we touched an unescaped quote, we must go through the remove escape code to remove it. + result.escaped = true; + } result.quoted = true; } @@ -160,6 +165,7 @@ class BaseScanner { template void Process(T &result) { idx_t to_pos; + const bool has_escaped_value = state_machine->dialect_options.state_machine_options.escape != '\0'; const idx_t start_pos = iterator.pos.buffer_pos; if (iterator.IsBoundarySet()) { to_pos = iterator.GetEndPos(); @@ -240,14 +246,15 @@ class BaseScanner { iterator.pos.buffer_pos++; break; case CSVState::QUOTED: { - if (states.states[0] == CSVState::UNQUOTED) { + if ((states.states[0] == CSVState::UNQUOTED || states.states[0] == CSVState::MAYBE_QUOTED) && + has_escaped_value) { T::SetEscaped(result); } ever_quoted = true; T::SetQuoted(result, iterator.pos.buffer_pos); iterator.pos.buffer_pos++; while (iterator.pos.buffer_pos + 8 < to_pos) { - uint64_t value = + const uint64_t value = Load(reinterpret_cast(&buffer_handle_ptr[iterator.pos.buffer_pos])); if (ContainsZeroByte((value ^ state_machine->transition_array.quote) & (value ^ state_machine->transition_array.escape))) { @@ -263,6 +270,9 @@ class BaseScanner { } } break; case CSVState::UNQUOTED: { + if (states.states[0] == CSVState::MAYBE_QUOTED) { + T::SetEscaped(result); + } T::SetUnquoted(result); iterator.pos.buffer_pos++; break; @@ -303,7 +313,7 @@ class BaseScanner { T::SetComment(result, iterator.pos.buffer_pos); iterator.pos.buffer_pos++; while (iterator.pos.buffer_pos + 8 < to_pos) { - uint64_t value = + const uint64_t value = Load(reinterpret_cast(&buffer_handle_ptr[iterator.pos.buffer_pos])); if (ContainsZeroByte((value ^ state_machine->transition_array.new_line) & (value ^ state_machine->transition_array.carriage_return))) { diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_state.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_state.hpp index e88e897aa..017ccfe39 100644 --- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_state.hpp +++ b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_state.hpp @@ -33,6 +33,7 @@ enum class CSVState : uint8_t { COMMENT = 14, //! If we are in a comment state, and hence have to skip the whole line STANDARD_NEWLINE = 15, //! State used for figuring out a new line. UNQUOTED_ESCAPE = 16, //! State when encountering an escape character (e.g., \) in an unquoted field - ESCAPED_RETURN = 17 //! State when the carriage return is preceded by an escape character (for '\r\n' newline only) + ESCAPED_RETURN = 17, //! State when the carriage return is preceded by an escape character (for '\r\n' newline only) + MAYBE_QUOTED = 18 //! We are potentially in a quoted value or the end of an unquoted value }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_state_machine.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_state_machine.hpp index 234a2c4c4..71eb1c11e 100644 --- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_state_machine.hpp +++ b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_state_machine.hpp @@ -90,7 +90,9 @@ struct CSVStates { case CSVState::ESCAPED_RETURN: return true; case CSVState::QUOTED: - return states[0] == CSVState::UNQUOTED; + return states[0] == CSVState::UNQUOTED || states[0] == CSVState::MAYBE_QUOTED; + case CSVState::UNQUOTED: + return states[0] == CSVState::MAYBE_QUOTED; default: return false; } diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_state_machine_cache.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_state_machine_cache.hpp index fdbafac02..2980370d5 100644 --- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_state_machine_cache.hpp +++ b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_state_machine_cache.hpp @@ -19,7 +19,7 @@ namespace duckdb { //! Class to wrap the state machine matrix class StateMachine { public: - static constexpr uint32_t NUM_STATES = 18; + static constexpr uint32_t NUM_STATES = 19; static constexpr uint32_t NUM_TRANSITIONS = 256; CSVState state_machine[NUM_TRANSITIONS][NUM_STATES]; //! Transitions where we might skip processing diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/string_value_scanner.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/string_value_scanner.hpp index 39f7b7f37..ad2250660 100644 --- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/string_value_scanner.hpp +++ b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/string_value_scanner.hpp @@ -315,7 +315,7 @@ class StringValueScanner : public BaseScanner { bool FinishedIterator() const; //! Creates a new string with all escaped values removed - static string_t RemoveEscape(const char *str_ptr, idx_t end, char escape, Vector &vector); + static string_t RemoveEscape(const char *str_ptr, idx_t end, char escape, char quote, Vector &vector); //! If we can directly cast the type when consuming the CSV file, or we have to do it later static bool CanDirectlyCast(const LogicalType &type, bool icu_loaded); diff --git a/src/duckdb/src/include/duckdb/function/function.hpp b/src/duckdb/src/include/duckdb/function/function.hpp index 89d4a0dab..9d39ef2f5 100644 --- a/src/duckdb/src/include/duckdb/function/function.hpp +++ b/src/duckdb/src/include/duckdb/function/function.hpp @@ -13,6 +13,7 @@ #include "duckdb/common/unordered_set.hpp" #include "duckdb/main/external_dependencies.hpp" #include "duckdb/parser/column_definition.hpp" +#include "duckdb/common/enums/function_errors.hpp" namespace duckdb { class CatalogEntry; @@ -43,6 +44,7 @@ enum class FunctionNullHandling : uint8_t { DEFAULT_NULL_HANDLING = 0, SPECIAL_H //! but the result might change across queries (e.g. NOW(), CURRENT_TIME) //! VOLATILE -> the result of this function might change per row (e.g. RANDOM()) enum class FunctionStability : uint8_t { CONSISTENT = 0, VOLATILE = 1, CONSISTENT_WITHIN_QUERY = 2 }; + //! How to handle collations //! PROPAGATE_COLLATIONS -> this function combines collation from its inputs and emits them again (default) //! PUSH_COMBINABLE_COLLATIONS -> combinable collations are executed for the input arguments @@ -159,7 +161,8 @@ class BaseScalarFunction : public SimpleFunction { DUCKDB_API BaseScalarFunction(string name, vector arguments, LogicalType return_type, FunctionStability stability, LogicalType varargs = LogicalType(LogicalTypeId::INVALID), - FunctionNullHandling null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING); + FunctionNullHandling null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING, + FunctionErrors errors = FunctionErrors::CANNOT_ERROR); DUCKDB_API ~BaseScalarFunction() override; //! Return type of the function @@ -168,9 +171,16 @@ class BaseScalarFunction : public SimpleFunction { FunctionStability stability; //! How this function handles NULL values FunctionNullHandling null_handling; + //! Whether or not this function can throw an error + FunctionErrors errors; //! Collation handling of the function FunctionCollationHandling collation_handling; + static BaseScalarFunction SetReturnsError(BaseScalarFunction &function) { + function.errors = FunctionErrors::CAN_THROW_RUNTIME_ERROR; + return function; + } + public: DUCKDB_API hash_t Hash() const; 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 bc0457ce9..eb9ba8c7c 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 @@ -38,6 +38,8 @@ class WindowLeadLagExecutor : public WindowValueExecutor { public: WindowLeadLagExecutor(BoundWindowExpression &wexpr, ClientContext &context, WindowSharedExpressions &shared); + unique_ptr GetGlobalState(const idx_t payload_count, const ValidityMask &partition_mask, + const ValidityMask &order_mask) const override; unique_ptr GetLocalState(const WindowExecutorGlobalState &gstate) const override; protected: diff --git a/src/duckdb/src/include/duckdb/main/relation/write_parquet_relation.hpp b/src/duckdb/src/include/duckdb/main/relation/write_parquet_relation.hpp index c67da3e20..d32089212 100644 --- a/src/duckdb/src/include/duckdb/main/relation/write_parquet_relation.hpp +++ b/src/duckdb/src/include/duckdb/main/relation/write_parquet_relation.hpp @@ -1,7 +1,7 @@ //===----------------------------------------------------------------------===// // DuckDB // -// duckdb/main/relation/write_csv_relation.hpp +// duckdb/main/relation/write_parquet_relation.hpp // // //===----------------------------------------------------------------------===// diff --git a/src/duckdb/src/include/duckdb/main/settings.hpp b/src/duckdb/src/include/duckdb/main/settings.hpp index 25dd24730..4e89c3416 100644 --- a/src/duckdb/src/include/duckdb/main/settings.hpp +++ b/src/duckdb/src/include/duckdb/main/settings.hpp @@ -188,7 +188,7 @@ struct ArrowLargeBufferSizeSetting { using RETURN_TYPE = bool; static constexpr const char *Name = "arrow_large_buffer_size"; static constexpr const char *Description = - "If arrow buffers for strings, blobs, uuids and bits should be exported using large buffers"; + "Whether Arrow buffers for strings, blobs, uuids and bits should be exported using large buffers"; static constexpr const char *InputType = "BOOLEAN"; static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); static void ResetGlobal(DatabaseInstance *db, DBConfig &config); @@ -211,7 +211,7 @@ struct ArrowOutputListViewSetting { using RETURN_TYPE = bool; static constexpr const char *Name = "arrow_output_list_view"; static constexpr const char *Description = - "If export to arrow format should use ListView as the physical layout for LIST columns"; + "Whether export to Arrow format should use ListView as the physical layout for LIST columns"; static constexpr const char *InputType = "BOOLEAN"; static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); static void ResetGlobal(DatabaseInstance *db, DBConfig &config); @@ -970,7 +970,7 @@ struct ProduceArrowStringViewSetting { using RETURN_TYPE = bool; static constexpr const char *Name = "produce_arrow_string_view"; static constexpr const char *Description = - "If strings should be produced by DuckDB in Utf8View format instead of Utf8"; + "Whether strings should be produced by DuckDB in Utf8View format instead of Utf8"; static constexpr const char *InputType = "BOOLEAN"; static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); static void ResetGlobal(DatabaseInstance *db, DBConfig &config); diff --git a/src/duckdb/src/include/duckdb/planner/expression/bound_function_expression.hpp b/src/duckdb/src/include/duckdb/planner/expression/bound_function_expression.hpp index e3d70c285..1698670bf 100644 --- a/src/duckdb/src/include/duckdb/planner/expression/bound_function_expression.hpp +++ b/src/duckdb/src/include/duckdb/planner/expression/bound_function_expression.hpp @@ -37,6 +37,7 @@ class BoundFunctionExpression : public Expression { bool IsVolatile() const override; bool IsConsistent() const override; bool IsFoldable() const override; + bool CanThrow() const override; string ToString() const override; bool PropagatesNullValues() const override; hash_t Hash() const override; diff --git a/src/duckdb/src/main/relation/read_csv_relation.cpp b/src/duckdb/src/main/relation/read_csv_relation.cpp index 25421a607..4720a8e52 100644 --- a/src/duckdb/src/main/relation/read_csv_relation.cpp +++ b/src/duckdb/src/main/relation/read_csv_relation.cpp @@ -13,7 +13,7 @@ #include "duckdb/parser/query_node/select_node.hpp" #include "duckdb/parser/tableref/basetableref.hpp" #include "duckdb/parser/tableref/table_function_ref.hpp" - +#include "duckdb/function/table/read_csv.hpp" namespace duckdb { void ReadCSVRelation::InitializeAlias(const vector &input) { @@ -46,34 +46,63 @@ ReadCSVRelation::ReadCSVRelation(const shared_ptr &context, const // Run the auto-detect, populating the options with the detected settings - shared_ptr buffer_manager; - if (csv_options.auto_detect) { - context->RunFunctionInTransaction([&]() { - buffer_manager = make_shared_ptr(*context, csv_options, files[0], 0); - CSVSniffer sniffer(csv_options, buffer_manager, CSVStateMachineCache::Get(*context)); - auto sniffer_result = sniffer.SniffCSV(); - auto &types = sniffer_result.return_types; - auto &names = sniffer_result.names; - for (idx_t i = 0; i < types.size(); i++) { - columns.emplace_back(names[i], types[i]); + if (csv_options.file_options.union_by_name) { + SimpleMultiFileList multi_file_list(files); + vector types; + vector names; + auto result = make_uniq(); + + multi_file_reader->BindUnionReader(*context, types, names, multi_file_list, *result, csv_options); + if (result->union_readers.size() > 1) { + for (idx_t i = 0; i < result->union_readers.size(); i++) { + result->column_info.emplace_back(result->union_readers[i]->names, result->union_readers[i]->types); + } + } + if (!csv_options.sql_types_per_column.empty()) { + const auto exception = CSVError::ColumnTypesError(csv_options.sql_types_per_column, names); + if (!exception.error_message.empty()) { + throw BinderException(exception.error_message); + } + for (idx_t i = 0; i < names.size(); i++) { + auto it = csv_options.sql_types_per_column.find(names[i]); + if (it != csv_options.sql_types_per_column.end()) { + types[i] = csv_options.sql_type_list[it->second]; + } } - }); + } + D_ASSERT(names.size() == types.size()); + for (idx_t i = 0; i < names.size(); i++) { + columns.emplace_back(names[i], types[i]); + } } else { - for (idx_t i = 0; i < csv_options.sql_type_list.size(); i++) { - D_ASSERT(csv_options.name_list.size() == csv_options.sql_type_list.size()); - columns.emplace_back(csv_options.name_list[i], csv_options.sql_type_list[i]); + if (csv_options.auto_detect) { + shared_ptr buffer_manager; + context->RunFunctionInTransaction([&]() { + buffer_manager = make_shared_ptr(*context, csv_options, files[0], 0); + CSVSniffer sniffer(csv_options, buffer_manager, CSVStateMachineCache::Get(*context)); + auto sniffer_result = sniffer.SniffCSV(); + auto &types = sniffer_result.return_types; + auto &names = sniffer_result.names; + for (idx_t i = 0; i < types.size(); i++) { + columns.emplace_back(names[i], types[i]); + } + }); + } else { + for (idx_t i = 0; i < csv_options.sql_type_list.size(); i++) { + D_ASSERT(csv_options.name_list.size() == csv_options.sql_type_list.size()); + columns.emplace_back(csv_options.name_list[i], csv_options.sql_type_list[i]); + } } + // After sniffing we can consider these set, so they are exported as named parameters + // FIXME: This is horribly hacky, should be refactored at some point + csv_options.dialect_options.state_machine_options.escape.ChangeSetByUserTrue(); + csv_options.dialect_options.state_machine_options.delimiter.ChangeSetByUserTrue(); + csv_options.dialect_options.state_machine_options.quote.ChangeSetByUserTrue(); + csv_options.dialect_options.header.ChangeSetByUserTrue(); + csv_options.dialect_options.skip_rows.ChangeSetByUserTrue(); } - // After sniffing we can consider these set, so they are exported as named parameters - // FIXME: This is horribly hacky, should be refactored at some point - csv_options.dialect_options.state_machine_options.escape.ChangeSetByUserTrue(); - csv_options.dialect_options.state_machine_options.delimiter.ChangeSetByUserTrue(); - csv_options.dialect_options.state_machine_options.quote.ChangeSetByUserTrue(); - csv_options.dialect_options.header.ChangeSetByUserTrue(); - csv_options.dialect_options.skip_rows.ChangeSetByUserTrue(); - - // Capture the options potentially set/altered by the auto detection phase + // Capture the options potentially set/altered by the auto-detection phase csv_options.ToNamedParameters(options); // No need to auto-detect again @@ -85,7 +114,9 @@ ReadCSVRelation::ReadCSVRelation(const shared_ptr &context, const column_names.push_back(make_pair(columns[i].Name(), Value(columns[i].Type().ToString()))); } - AddNamedParameter("columns", Value::STRUCT(std::move(column_names))); + if (!csv_options.file_options.union_by_name) { + AddNamedParameter("columns", Value::STRUCT(std::move(column_names))); + } RemoveNamedParameterIfExists("names"); RemoveNamedParameterIfExists("types"); RemoveNamedParameterIfExists("dtypes"); diff --git a/src/duckdb/src/optimizer/join_order/relation_manager.cpp b/src/duckdb/src/optimizer/join_order/relation_manager.cpp index 5e809a4c5..d4f7032d6 100644 --- a/src/duckdb/src/optimizer/join_order/relation_manager.cpp +++ b/src/duckdb/src/optimizer/join_order/relation_manager.cpp @@ -1,6 +1,7 @@ #include "duckdb/optimizer/join_order/relation_manager.hpp" #include "duckdb/common/enums/join_type.hpp" +#include "duckdb/common/enums/logical_operator_type.hpp" #include "duckdb/common/string_util.hpp" #include "duckdb/optimizer/join_order/join_order_optimizer.hpp" #include "duckdb/optimizer/join_order/relation_statistics_helper.hpp" @@ -64,6 +65,13 @@ void RelationManager::AddRelation(LogicalOperator &op, optional_ptr catalog, c } } -static void FindMatchingPrimaryKeyColumns(const ColumnList &columns, const vector> &constraints, - ForeignKeyConstraint &fk) { - // find the matching primary key constraint - bool found_constraint = false; - // if no columns are defined, we will automatically try to bind to the primary key - bool find_primary_key = fk.pk_columns.empty(); - for (auto &constr : constraints) { - if (constr->type != ConstraintType::UNIQUE) { - continue; - } - auto &unique = constr->Cast(); - if (find_primary_key && !unique.IsPrimaryKey()) { - continue; - } - found_constraint = true; - - vector pk_names; - if (unique.HasIndex()) { - pk_names.push_back(columns.GetColumn(LogicalIndex(unique.GetIndex())).Name()); - } else { - pk_names = unique.GetColumnNames(); - } - if (find_primary_key) { - // found matching primary key - if (pk_names.size() != fk.fk_columns.size()) { - auto pk_name_str = StringUtil::Join(pk_names, ","); - auto fk_name_str = StringUtil::Join(fk.fk_columns, ","); - throw BinderException( - "Failed to create foreign key: number of referencing (%s) and referenced columns (%s) differ", - fk_name_str, pk_name_str); - } - fk.pk_columns = pk_names; - return; - } - if (pk_names.size() != fk.fk_columns.size()) { - // the number of referencing and referenced columns for foreign keys must be the same - continue; - } - bool equals = true; - for (idx_t i = 0; i < fk.pk_columns.size(); i++) { - if (!StringUtil::CIEquals(fk.pk_columns[i], pk_names[i])) { - equals = false; - break; - } - } - if (!equals) { - continue; - } - // found match - return; - } - // no match found! examine why - if (!found_constraint) { - // no unique constraint or primary key - string search_term = find_primary_key ? "primary key" : "primary key or unique constraint"; - throw BinderException("Failed to create foreign key: there is no %s for referenced table \"%s\"", search_term, - fk.info.table); - } - // check if all the columns exist - for (auto &name : fk.pk_columns) { - bool found = columns.ColumnExists(name); - if (!found) { - throw BinderException( - "Failed to create foreign key: referenced table \"%s\" does not have a column named \"%s\"", - fk.info.table, name); - } - } - auto fk_names = StringUtil::Join(fk.pk_columns, ","); - throw BinderException("Failed to create foreign key: referenced table \"%s\" does not have a primary key or unique " - "constraint on the columns %s", - fk.info.table, fk_names); -} - -static void FindForeignKeyIndexes(const ColumnList &columns, const vector &names, - vector &indexes) { - D_ASSERT(indexes.empty()); - D_ASSERT(!names.empty()); - for (auto &name : names) { - if (!columns.ColumnExists(name)) { - throw BinderException("column \"%s\" named in key does not exist", name); - } - auto &column = columns.GetColumn(name); - if (column.Generated()) { - throw BinderException("Failed to create foreign key: referenced column \"%s\" is a generated column", - column.Name()); - } - indexes.push_back(column.Physical()); - } -} - -static void CheckForeignKeyTypes(const ColumnList &pk_columns, const ColumnList &fk_columns, ForeignKeyConstraint &fk) { - D_ASSERT(fk.info.pk_keys.size() == fk.info.fk_keys.size()); - for (idx_t c_idx = 0; c_idx < fk.info.pk_keys.size(); c_idx++) { - auto &pk_col = pk_columns.GetColumn(fk.info.pk_keys[c_idx]); - auto &fk_col = fk_columns.GetColumn(fk.info.fk_keys[c_idx]); - if (pk_col.Type() != fk_col.Type()) { - throw BinderException("Failed to create foreign key: incompatible types between column \"%s\" (\"%s\") and " - "column \"%s\" (\"%s\")", - pk_col.Name(), pk_col.Type().ToString(), fk_col.Name(), fk_col.Type().ToString()); - } - } -} - -void ExpressionContainsGeneratedColumn(const ParsedExpression &expr, const unordered_set &gcols, - bool &contains_gcol) { - if (contains_gcol) { - return; - } - if (expr.GetExpressionType() == ExpressionType::COLUMN_REF) { - auto &column_ref = expr.Cast(); - auto &name = column_ref.GetColumnName(); - if (gcols.count(name)) { - contains_gcol = true; - return; - } - } - ParsedExpressionIterator::EnumerateChildren( - expr, [&](const ParsedExpression &child) { ExpressionContainsGeneratedColumn(child, gcols, contains_gcol); }); -} - -static bool AnyConstraintReferencesGeneratedColumn(CreateTableInfo &table_info) { - unordered_set generated_columns; - for (auto &col : table_info.columns.Logical()) { - if (!col.Generated()) { - continue; - } - generated_columns.insert(col.Name()); - } - if (generated_columns.empty()) { - return false; - } - - for (auto &constr : table_info.constraints) { - switch (constr->type) { - case ConstraintType::CHECK: { - auto &constraint = constr->Cast(); - auto &expr = constraint.expression; - bool contains_generated_column = false; - ExpressionContainsGeneratedColumn(*expr, generated_columns, contains_generated_column); - if (contains_generated_column) { - return true; - } - break; - } - case ConstraintType::NOT_NULL: { - auto &constraint = constr->Cast(); - if (table_info.columns.GetColumn(constraint.index).Generated()) { - return true; - } - break; - } - case ConstraintType::UNIQUE: { - auto &constraint = constr->Cast(); - if (!constraint.HasIndex()) { - for (auto &col : constraint.GetColumnNames()) { - if (generated_columns.count(col)) { - return true; - } - } - } else { - if (table_info.columns.GetColumn(constraint.GetIndex()).Generated()) { - return true; - } - } - break; - } - case ConstraintType::FOREIGN_KEY: { - // If it contained a generated column, an exception would have been thrown inside AddDataTableIndex earlier - break; - } - default: { - throw NotImplementedException("ConstraintType not implemented"); - } - } - } - return false; -} - unique_ptr DuckCatalog::BindCreateIndex(Binder &binder, CreateStatement &stmt, TableCatalogEntry &table, unique_ptr plan) { D_ASSERT(plan->type == LogicalOperatorType::LOGICAL_GET); @@ -646,66 +468,8 @@ BoundStatement Binder::Bind(CreateStatement &stmt) { break; } case CatalogType::TABLE_ENTRY: { - auto &create_info = stmt.info->Cast(); - // If there is a foreign key constraint, resolve primary key column's index from primary key column's name - reference_set_t fk_schemas; - for (idx_t i = 0; i < create_info.constraints.size(); i++) { - auto &cond = create_info.constraints[i]; - if (cond->type != ConstraintType::FOREIGN_KEY) { - continue; - } - auto &fk = cond->Cast(); - if (fk.info.type != ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) { - continue; - } - D_ASSERT(fk.info.pk_keys.empty()); - D_ASSERT(fk.info.fk_keys.empty()); - FindForeignKeyIndexes(create_info.columns, fk.fk_columns, fk.info.fk_keys); - - // Resolve the self-reference. - if (StringUtil::CIEquals(create_info.table, fk.info.table)) { - fk.info.type = ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE; - FindMatchingPrimaryKeyColumns(create_info.columns, create_info.constraints, fk); - FindForeignKeyIndexes(create_info.columns, fk.pk_columns, fk.info.pk_keys); - CheckForeignKeyTypes(create_info.columns, create_info.columns, fk); - continue; - } - - // Resolve the table reference. - auto table_entry = - entry_retriever.GetEntry(CatalogType::TABLE_ENTRY, INVALID_CATALOG, fk.info.schema, fk.info.table); - if (table_entry->type == CatalogType::VIEW_ENTRY) { - throw BinderException("cannot reference a VIEW with a FOREIGN KEY"); - } - - auto &pk_table_entry_ptr = table_entry->Cast(); - fk_schemas.insert(pk_table_entry_ptr.schema); - FindMatchingPrimaryKeyColumns(pk_table_entry_ptr.GetColumns(), pk_table_entry_ptr.GetConstraints(), fk); - FindForeignKeyIndexes(pk_table_entry_ptr.GetColumns(), fk.pk_columns, fk.info.pk_keys); - CheckForeignKeyTypes(pk_table_entry_ptr.GetColumns(), create_info.columns, fk); - auto &storage = pk_table_entry_ptr.GetStorage(); - - if (!storage.HasForeignKeyIndex(fk.info.pk_keys, ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE)) { - auto fk_column_names = StringUtil::Join(fk.pk_columns, ","); - throw BinderException("Failed to create foreign key on %s(%s): no UNIQUE or PRIMARY KEY constraint " - "present on these columns", - pk_table_entry_ptr.name, fk_column_names); - } - - D_ASSERT(fk.info.pk_keys.size() == fk.info.fk_keys.size()); - D_ASSERT(fk.info.pk_keys.size() == fk.pk_columns.size()); - D_ASSERT(fk.info.fk_keys.size() == fk.fk_columns.size()); - } - if (AnyConstraintReferencesGeneratedColumn(create_info)) { - throw BinderException("Constraints on generated columns are not supported yet"); - } auto bound_info = BindCreateTableInfo(std::move(stmt.info)); auto root = std::move(bound_info->query); - for (auto &fk_schema : fk_schemas) { - if (&fk_schema.get() != &bound_info->schema) { - throw BinderException("Creating foreign keys across different schemas or catalogs is not supported"); - } - } // create the logical operator auto &schema = bound_info->schema; 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 6a6bd564d..80d50d074 100644 --- a/src/duckdb/src/planner/binder/statement/bind_create_table.cpp +++ b/src/duckdb/src/planner/binder/statement/bind_create_table.cpp @@ -19,6 +19,8 @@ #include "duckdb/planner/expression_binder/index_binder.hpp" #include "duckdb/parser/parsed_data/create_index_info.hpp" #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp" +#include "duckdb/parser/parsed_expression_iterator.hpp" +#include "duckdb/storage/data_table.hpp" namespace duckdb { @@ -309,6 +311,242 @@ unique_ptr Binder::BindCreateTableCheckpoint(unique_ptr &gcols, + bool &contains_gcol) { + if (contains_gcol) { + return; + } + if (expr.GetExpressionType() == ExpressionType::COLUMN_REF) { + auto &column_ref = expr.Cast(); + auto &name = column_ref.GetColumnName(); + if (gcols.count(name)) { + contains_gcol = true; + return; + } + } + ParsedExpressionIterator::EnumerateChildren( + expr, [&](const ParsedExpression &child) { ExpressionContainsGeneratedColumn(child, gcols, contains_gcol); }); +} + +static bool AnyConstraintReferencesGeneratedColumn(CreateTableInfo &table_info) { + unordered_set generated_columns; + for (auto &col : table_info.columns.Logical()) { + if (!col.Generated()) { + continue; + } + generated_columns.insert(col.Name()); + } + if (generated_columns.empty()) { + return false; + } + + for (auto &constr : table_info.constraints) { + switch (constr->type) { + case ConstraintType::CHECK: { + auto &constraint = constr->Cast(); + auto &expr = constraint.expression; + bool contains_generated_column = false; + ExpressionContainsGeneratedColumn(*expr, generated_columns, contains_generated_column); + if (contains_generated_column) { + return true; + } + break; + } + case ConstraintType::NOT_NULL: { + auto &constraint = constr->Cast(); + if (table_info.columns.GetColumn(constraint.index).Generated()) { + return true; + } + break; + } + case ConstraintType::UNIQUE: { + auto &constraint = constr->Cast(); + if (!constraint.HasIndex()) { + for (auto &col : constraint.GetColumnNames()) { + if (generated_columns.count(col)) { + return true; + } + } + } else { + if (table_info.columns.GetColumn(constraint.GetIndex()).Generated()) { + return true; + } + } + break; + } + case ConstraintType::FOREIGN_KEY: { + // If it contained a generated column, an exception would have been thrown inside AddDataTableIndex earlier + break; + } + default: { + throw NotImplementedException("ConstraintType not implemented"); + } + } + } + return false; +} + +static void FindForeignKeyIndexes(const ColumnList &columns, const vector &names, + vector &indexes) { + D_ASSERT(indexes.empty()); + D_ASSERT(!names.empty()); + for (auto &name : names) { + if (!columns.ColumnExists(name)) { + throw BinderException("column \"%s\" named in key does not exist", name); + } + auto &column = columns.GetColumn(name); + if (column.Generated()) { + throw BinderException("Failed to create foreign key: referenced column \"%s\" is a generated column", + column.Name()); + } + indexes.push_back(column.Physical()); + } +} + +static void FindMatchingPrimaryKeyColumns(const ColumnList &columns, const vector> &constraints, + ForeignKeyConstraint &fk) { + // find the matching primary key constraint + bool found_constraint = false; + // if no columns are defined, we will automatically try to bind to the primary key + bool find_primary_key = fk.pk_columns.empty(); + for (auto &constr : constraints) { + if (constr->type != ConstraintType::UNIQUE) { + continue; + } + auto &unique = constr->Cast(); + if (find_primary_key && !unique.IsPrimaryKey()) { + continue; + } + found_constraint = true; + + vector pk_names; + if (unique.HasIndex()) { + pk_names.push_back(columns.GetColumn(LogicalIndex(unique.GetIndex())).Name()); + } else { + pk_names = unique.GetColumnNames(); + } + if (find_primary_key) { + // found matching primary key + if (pk_names.size() != fk.fk_columns.size()) { + auto pk_name_str = StringUtil::Join(pk_names, ","); + auto fk_name_str = StringUtil::Join(fk.fk_columns, ","); + throw BinderException( + "Failed to create foreign key: number of referencing (%s) and referenced columns (%s) differ", + fk_name_str, pk_name_str); + } + fk.pk_columns = pk_names; + return; + } + if (pk_names.size() != fk.fk_columns.size()) { + // the number of referencing and referenced columns for foreign keys must be the same + continue; + } + bool equals = true; + for (idx_t i = 0; i < fk.pk_columns.size(); i++) { + if (!StringUtil::CIEquals(fk.pk_columns[i], pk_names[i])) { + equals = false; + break; + } + } + if (!equals) { + continue; + } + // found match + return; + } + // no match found! examine why + if (!found_constraint) { + // no unique constraint or primary key + string search_term = find_primary_key ? "primary key" : "primary key or unique constraint"; + throw BinderException("Failed to create foreign key: there is no %s for referenced table \"%s\"", search_term, + fk.info.table); + } + // check if all the columns exist + for (auto &name : fk.pk_columns) { + bool found = columns.ColumnExists(name); + if (!found) { + throw BinderException( + "Failed to create foreign key: referenced table \"%s\" does not have a column named \"%s\"", + fk.info.table, name); + } + } + auto fk_names = StringUtil::Join(fk.pk_columns, ","); + throw BinderException("Failed to create foreign key: referenced table \"%s\" does not have a primary key or unique " + "constraint on the columns %s", + fk.info.table, fk_names); +} + +static void CheckForeignKeyTypes(const ColumnList &pk_columns, const ColumnList &fk_columns, ForeignKeyConstraint &fk) { + D_ASSERT(fk.info.pk_keys.size() == fk.info.fk_keys.size()); + for (idx_t c_idx = 0; c_idx < fk.info.pk_keys.size(); c_idx++) { + auto &pk_col = pk_columns.GetColumn(fk.info.pk_keys[c_idx]); + auto &fk_col = fk_columns.GetColumn(fk.info.fk_keys[c_idx]); + if (pk_col.Type() != fk_col.Type()) { + throw BinderException("Failed to create foreign key: incompatible types between column \"%s\" (\"%s\") and " + "column \"%s\" (\"%s\")", + pk_col.Name(), pk_col.Type().ToString(), fk_col.Name(), fk_col.Type().ToString()); + } + } +} + +static void BindCreateTableConstraints(CreateTableInfo &create_info, CatalogEntryRetriever &entry_retriever, + SchemaCatalogEntry &schema) { + // If there is a foreign key constraint, resolve primary key column's index from primary key column's name + reference_set_t fk_schemas; + for (idx_t i = 0; i < create_info.constraints.size(); i++) { + auto &cond = create_info.constraints[i]; + if (cond->type != ConstraintType::FOREIGN_KEY) { + continue; + } + auto &fk = cond->Cast(); + if (fk.info.type != ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) { + continue; + } + if (!fk.info.pk_keys.empty() && !fk.info.fk_keys.empty()) { + return; + } + D_ASSERT(fk.info.pk_keys.empty()); + D_ASSERT(fk.info.fk_keys.empty()); + FindForeignKeyIndexes(create_info.columns, fk.fk_columns, fk.info.fk_keys); + + // Resolve the self-reference. + if (StringUtil::CIEquals(create_info.table, fk.info.table)) { + fk.info.type = ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE; + FindMatchingPrimaryKeyColumns(create_info.columns, create_info.constraints, fk); + FindForeignKeyIndexes(create_info.columns, fk.pk_columns, fk.info.pk_keys); + CheckForeignKeyTypes(create_info.columns, create_info.columns, fk); + continue; + } + + // Resolve the table reference. + auto table_entry = + entry_retriever.GetEntry(CatalogType::TABLE_ENTRY, INVALID_CATALOG, fk.info.schema, fk.info.table); + if (table_entry->type == CatalogType::VIEW_ENTRY) { + throw BinderException("cannot reference a VIEW with a FOREIGN KEY"); + } + + auto &pk_table_entry_ptr = table_entry->Cast(); + if (&pk_table_entry_ptr.schema != &schema) { + throw BinderException("Creating foreign keys across different schemas or catalogs is not supported"); + } + FindMatchingPrimaryKeyColumns(pk_table_entry_ptr.GetColumns(), pk_table_entry_ptr.GetConstraints(), fk); + FindForeignKeyIndexes(pk_table_entry_ptr.GetColumns(), fk.pk_columns, fk.info.pk_keys); + CheckForeignKeyTypes(pk_table_entry_ptr.GetColumns(), create_info.columns, fk); + auto &storage = pk_table_entry_ptr.GetStorage(); + + if (!storage.HasForeignKeyIndex(fk.info.pk_keys, ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE)) { + auto fk_column_names = StringUtil::Join(fk.pk_columns, ","); + throw BinderException("Failed to create foreign key on %s(%s): no UNIQUE or PRIMARY KEY constraint " + "present on these columns", + pk_table_entry_ptr.name, fk_column_names); + } + + D_ASSERT(fk.info.pk_keys.size() == fk.info.fk_keys.size()); + D_ASSERT(fk.info.pk_keys.size() == fk.pk_columns.size()); + D_ASSERT(fk.info.fk_keys.size() == fk.fk_columns.size()); + } +} + unique_ptr Binder::BindCreateTableInfo(unique_ptr info, SchemaCatalogEntry &schema, vector> &bound_defaults) { auto &base = info->Cast(); @@ -350,6 +588,14 @@ unique_ptr Binder::BindCreateTableInfo(unique_ptrschema.catalog, result->schema.name); + } } else { SetCatalogLookupCallback([&dependencies, &schema](CatalogEntry &entry) { if (&schema.ParentCatalog() != &entry.ParentCatalog()) { @@ -362,6 +608,20 @@ unique_ptr Binder::BindCreateTableInfo(unique_ptrschema.catalog, result->schema.name); + } + BindCreateTableConstraints(base, entry_retriever, schema); + + if (AnyConstraintReferencesGeneratedColumn(base)) { + throw BinderException("Constraints on generated columns are not supported yet"); + } bound_constraints = BindNewConstraints(base.constraints, base.table, base.columns); // bind the default values auto &catalog_name = schema.ParentCatalog().GetName(); @@ -372,14 +632,7 @@ unique_ptr Binder::BindCreateTableInfo(unique_ptrschema.catalog, result->schema.name); - } + result->dependencies.VerifyDependencies(schema.catalog, result->Base().table); auto &properties = GetStatementProperties(); diff --git a/src/duckdb/src/planner/expression/bound_function_expression.cpp b/src/duckdb/src/planner/expression/bound_function_expression.cpp index aa00288ae..1be272540 100644 --- a/src/duckdb/src/planner/expression/bound_function_expression.cpp +++ b/src/duckdb/src/planner/expression/bound_function_expression.cpp @@ -42,6 +42,13 @@ bool BoundFunctionExpression::IsFoldable() const { return function.stability == FunctionStability::VOLATILE ? false : Expression::IsFoldable(); } +bool BoundFunctionExpression::CanThrow() const { + if (function.errors == FunctionErrors::CAN_THROW_RUNTIME_ERROR) { + return true; + } + return Expression::CanThrow(); +} + string BoundFunctionExpression::ToString() const { return FunctionExpression::ToString(*this, string(), string(), function.name, is_operator); diff --git a/src/duckdb/src/storage/compression/roaring/common.cpp b/src/duckdb/src/storage/compression/roaring/common.cpp index 709b13f39..d680a4d02 100644 --- a/src/duckdb/src/storage/compression/roaring/common.cpp +++ b/src/duckdb/src/storage/compression/roaring/common.cpp @@ -242,14 +242,14 @@ void RoaringSkip(ColumnSegment &segment, ColumnScanState &state, idx_t skip_coun return; } -} // namespace roaring - unique_ptr RoaringInitSegment(ColumnSegment &segment, block_id_t block_id, optional_ptr segment_state) { // 'ValidityInitSegment' is used normally, which memsets the page to all bits set. return nullptr; } +} // namespace roaring + //===--------------------------------------------------------------------===// // Get Function //===--------------------------------------------------------------------===// @@ -258,7 +258,7 @@ CompressionFunction GetCompressionFunction(PhysicalType data_type) { roaring::RoaringAnalyze, roaring::RoaringFinalAnalyze, roaring::RoaringInitCompression, roaring::RoaringCompress, roaring::RoaringFinalizeCompress, roaring::RoaringInitScan, roaring::RoaringScan, roaring::RoaringScanPartial, roaring::RoaringFetchRow, - roaring::RoaringSkip, RoaringInitSegment); + roaring::RoaringSkip, roaring::RoaringInitSegment); } CompressionFunction RoaringCompressionFun::GetFunction(PhysicalType type) { diff --git a/src/duckdb/third_party/fsst/libfsst.hpp b/src/duckdb/third_party/fsst/libfsst.hpp index fdc7d83a1..0d556386a 100644 --- a/src/duckdb/third_party/fsst/libfsst.hpp +++ b/src/duckdb/third_party/fsst/libfsst.hpp @@ -17,6 +17,7 @@ // You can contact the authors via the FSST source repository : https://github.com/cwida/fsst #include #include +#include #include #include #include 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 f00474b32..71ed8b023 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 @@ -1626,7 +1626,7 @@ union yyalloc /* YYFINAL -- State number of the termination state. */ #define YYFINAL 874 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 74594 +#define YYLAST 74510 /* YYNTOKENS -- Number of terminals. */ #define YYNTOKENS 529 @@ -1635,7 +1635,7 @@ union yyalloc /* YYNRULES -- Number of rules. */ #define YYNRULES 2176 /* YYNRULES -- Number of states. */ -#define YYNSTATES 3616 +#define YYNSTATES 3617 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ #define YYUNDEFTOK 2 @@ -1836,119 +1836,119 @@ static const yytype_uint16 yyprhs[] = 3548, 3555, 3563, 3565, 3568, 3570, 3572, 3574, 3577, 3580, 3585, 3589, 3591, 3593, 3595, 3597, 3600, 3602, 3604, 3606, 3608, 3610, 3612, 3614, 3617, 3622, 3625, 3629, 3633, 3638, - 3642, 3647, 3654, 3662, 3672, 3680, 3688, 3694, 3696, 3698, - 3700, 3706, 3713, 3720, 3725, 3730, 3735, 3740, 3747, 3753, - 3759, 3765, 3770, 3777, 3782, 3784, 3792, 3802, 3808, 3809, - 3815, 3820, 3821, 3823, 3824, 3827, 3828, 3830, 3834, 3838, - 3841, 3844, 3845, 3852, 3854, 3855, 3859, 3860, 3864, 3868, - 3872, 3873, 3875, 3880, 3883, 3886, 3889, 3892, 3895, 3899, - 3902, 3905, 3909, 3910, 3915, 3919, 3921, 3927, 3931, 3933, - 3937, 3939, 3942, 3946, 3948, 3952, 3954, 3957, 3959, 3960, - 3962, 3964, 3966, 3968, 3970, 3972, 3974, 3976, 3978, 3980, - 3982, 3984, 3986, 3988, 3990, 3992, 3994, 3996, 3998, 4000, - 4005, 4007, 4012, 4014, 4019, 4021, 4024, 4026, 4029, 4031, - 4034, 4036, 4040, 4042, 4046, 4048, 4051, 4053, 4057, 4059, - 4062, 4064, 4065, 4067, 4071, 4073, 4077, 4081, 4083, 4087, - 4091, 4092, 4094, 4096, 4098, 4100, 4102, 4104, 4106, 4108, - 4110, 4112, 4114, 4116, 4118, 4120, 4122, 4127, 4131, 4134, - 4138, 4139, 4143, 4147, 4150, 4153, 4155, 4156, 4159, 4162, - 4166, 4169, 4171, 4173, 4177, 4179, 4181, 4187, 4189, 4192, - 4197, 4200, 4201, 4203, 4204, 4206, 4210, 4212, 4214, 4217, - 4221, 4227, 4235, 4243, 4245, 4246, 4247, 4250, 4251, 4254, - 4258, 4262, 4266, 4272, 4280, 4288, 4289, 4292, 4294, 4295, - 4297, 4298, 4300, 4304, 4306, 4309, 4313, 4316, 4318, 4322, - 4327, 4330, 4332, 4336, 4338, 4342, 4344, 4347, 4349, 4350, - 4354, 4356, 4360, 4362, 4365, 4370, 4373, 4374, 4378, 4380, - 4384, 4386, 4389, 4394, 4397, 4398, 4400, 4404, 4406, 4410, - 4412, 4415, 4417, 4421, 4423, 4425, 4428, 4430, 4432, 4435, - 4437, 4439, 4442, 4450, 4453, 4459, 4463, 4467, 4469, 4471, - 4473, 4475, 4477, 4479, 4481, 4483, 4485, 4487, 4489, 4491, - 4493, 4495, 4498, 4501, 4505, 4509, 4510, 4512, 4514, 4516, - 4522, 4526, 4527, 4529, 4531, 4533, 4535, 4537, 4539, 4544, - 4552, 4559, 4562, 4563, 4565, 4567, 4569, 4571, 4585, 4602, - 4604, 4607, 4608, 4610, 4611, 4613, 4614, 4617, 4618, 4620, - 4621, 4628, 4637, 4644, 4653, 4660, 4669, 4673, 4676, 4678, - 4679, 4686, 4693, 4695, 4697, 4699, 4701, 4703, 4705, 4708, - 4710, 4712, 4714, 4716, 4718, 4723, 4730, 4734, 4737, 4742, - 4746, 4752, 4754, 4755, 4757, 4759, 4760, 4762, 4764, 4766, - 4768, 4770, 4772, 4774, 4776, 4778, 4780, 4782, 4784, 4786, - 4788, 4790, 4792, 4794, 4796, 4798, 4800, 4802, 4804, 4806, - 4808, 4810, 4812, 4814, 4816, 4818, 4820, 4822, 4824, 4826, - 4828, 4830, 4832, 4834, 4838, 4840, 4842, 4844, 4846, 4848, - 4850, 4853, 4855, 4857, 4860, 4864, 4868, 4872, 4876, 4878, - 4882, 4886, 4889, 4893, 4897, 4899, 4901, 4903, 4907, 4913, - 4915, 4917, 4919, 4921, 4925, 4928, 4933, 4940, 4947, 4948, - 4950, 4952, 4954, 4955, 4958, 4961, 4966, 4973, 4979, 4984, - 4991, 4993, 4995, 4997, 4999, 5001, 5003, 5004, 5006, 5010, - 5012, 5013, 5021, 5025, 5027, 5030, 5034, 5037, 5038, 5041, - 5042, 5045, 5050, 5056, 5065, 5068, 5072, 5078, 5080, 5081, - 5084, 5085, 5088, 5092, 5096, 5100, 5104, 5106, 5108, 5110, - 5113, 5117, 5120, 5123, 5126, 5129, 5133, 5138, 5142, 5144, - 5146, 5148, 5150, 5152, 5154, 5155, 5157, 5161, 5164, 5174, - 5187, 5199, 5212, 5227, 5231, 5236, 5241, 5242, 5250, 5261, - 5271, 5274, 5278, 5279, 5284, 5286, 5288, 5290, 5292, 5294, - 5296, 5298, 5300, 5302, 5304, 5306, 5308, 5310, 5312, 5314, - 5316, 5318, 5320, 5322, 5324, 5326, 5328, 5330, 5332, 5334, - 5336, 5338, 5340, 5342, 5344, 5346, 5348, 5350, 5352, 5354, - 5356, 5358, 5360, 5362, 5364, 5366, 5368, 5370, 5372, 5374, - 5376, 5378, 5380, 5382, 5384, 5386, 5388, 5390, 5392, 5394, - 5396, 5398, 5400, 5402, 5404, 5406, 5408, 5410, 5412, 5414, - 5416, 5418, 5420, 5422, 5424, 5426, 5428, 5430, 5432, 5434, - 5436, 5438, 5440, 5442, 5444, 5446, 5448, 5450, 5452, 5454, - 5456, 5458, 5460, 5462, 5464, 5466, 5468, 5470, 5472, 5474, - 5476, 5478, 5480, 5482, 5484, 5486, 5488, 5490, 5492, 5494, - 5496, 5498, 5500, 5502, 5504, 5506, 5508, 5510, 5512, 5514, - 5516, 5518, 5520, 5522, 5524, 5526, 5528, 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 + 3642, 3648, 3655, 3663, 3673, 3681, 3689, 3695, 3697, 3699, + 3701, 3707, 3714, 3721, 3726, 3731, 3736, 3741, 3748, 3754, + 3760, 3766, 3771, 3778, 3783, 3785, 3793, 3803, 3809, 3810, + 3816, 3821, 3822, 3824, 3825, 3828, 3829, 3831, 3835, 3839, + 3842, 3845, 3846, 3853, 3855, 3856, 3860, 3861, 3865, 3869, + 3873, 3874, 3876, 3881, 3884, 3887, 3890, 3893, 3896, 3900, + 3903, 3906, 3910, 3911, 3916, 3920, 3922, 3928, 3932, 3934, + 3938, 3940, 3943, 3947, 3949, 3953, 3955, 3958, 3960, 3961, + 3963, 3965, 3967, 3969, 3971, 3973, 3975, 3977, 3979, 3981, + 3983, 3985, 3987, 3989, 3991, 3993, 3995, 3997, 3999, 4001, + 4006, 4008, 4013, 4015, 4020, 4022, 4025, 4027, 4030, 4032, + 4035, 4037, 4041, 4043, 4047, 4049, 4052, 4054, 4058, 4060, + 4063, 4065, 4066, 4068, 4072, 4074, 4078, 4082, 4084, 4088, + 4092, 4093, 4095, 4097, 4099, 4101, 4103, 4105, 4107, 4109, + 4111, 4113, 4115, 4117, 4119, 4121, 4123, 4128, 4132, 4135, + 4139, 4140, 4144, 4148, 4151, 4154, 4156, 4157, 4160, 4163, + 4167, 4170, 4172, 4174, 4178, 4180, 4182, 4188, 4190, 4193, + 4198, 4201, 4202, 4204, 4205, 4207, 4211, 4213, 4215, 4218, + 4222, 4228, 4236, 4244, 4246, 4247, 4248, 4251, 4252, 4255, + 4259, 4263, 4267, 4273, 4281, 4289, 4290, 4293, 4295, 4296, + 4298, 4299, 4301, 4305, 4307, 4310, 4314, 4317, 4319, 4323, + 4328, 4331, 4333, 4337, 4339, 4343, 4345, 4348, 4350, 4351, + 4355, 4357, 4361, 4363, 4366, 4371, 4374, 4375, 4379, 4381, + 4385, 4387, 4390, 4395, 4398, 4399, 4401, 4405, 4407, 4411, + 4413, 4416, 4418, 4422, 4424, 4426, 4429, 4431, 4433, 4436, + 4438, 4440, 4443, 4451, 4454, 4460, 4464, 4468, 4470, 4472, + 4474, 4476, 4478, 4480, 4482, 4484, 4486, 4488, 4490, 4492, + 4494, 4496, 4499, 4502, 4506, 4510, 4511, 4513, 4515, 4517, + 4523, 4527, 4528, 4530, 4532, 4534, 4536, 4538, 4540, 4545, + 4553, 4560, 4563, 4564, 4566, 4568, 4570, 4572, 4586, 4603, + 4605, 4608, 4609, 4611, 4612, 4614, 4615, 4618, 4619, 4621, + 4622, 4629, 4638, 4645, 4654, 4661, 4670, 4674, 4677, 4679, + 4680, 4687, 4694, 4696, 4698, 4700, 4702, 4704, 4706, 4709, + 4711, 4713, 4715, 4717, 4719, 4724, 4731, 4735, 4738, 4743, + 4747, 4753, 4755, 4756, 4758, 4760, 4761, 4763, 4765, 4767, + 4769, 4771, 4773, 4775, 4777, 4779, 4781, 4783, 4785, 4787, + 4789, 4791, 4793, 4795, 4797, 4799, 4801, 4803, 4805, 4807, + 4809, 4811, 4813, 4815, 4817, 4819, 4821, 4823, 4825, 4827, + 4829, 4831, 4833, 4835, 4839, 4841, 4843, 4845, 4847, 4849, + 4851, 4854, 4856, 4858, 4861, 4865, 4869, 4873, 4877, 4879, + 4883, 4887, 4890, 4894, 4898, 4900, 4902, 4904, 4908, 4914, + 4916, 4918, 4920, 4922, 4926, 4929, 4934, 4941, 4948, 4949, + 4951, 4953, 4955, 4956, 4959, 4962, 4967, 4974, 4980, 4985, + 4992, 4994, 4996, 4998, 5000, 5002, 5004, 5005, 5007, 5011, + 5013, 5014, 5022, 5026, 5028, 5031, 5035, 5038, 5039, 5042, + 5043, 5046, 5051, 5057, 5066, 5069, 5073, 5079, 5081, 5082, + 5085, 5086, 5089, 5093, 5097, 5101, 5105, 5107, 5109, 5111, + 5114, 5118, 5121, 5124, 5127, 5130, 5134, 5139, 5143, 5145, + 5147, 5149, 5151, 5153, 5155, 5156, 5158, 5162, 5165, 5175, + 5188, 5200, 5213, 5228, 5232, 5237, 5242, 5243, 5251, 5262, + 5272, 5275, 5279, 5280, 5285, 5287, 5289, 5291, 5293, 5295, + 5297, 5299, 5301, 5303, 5305, 5307, 5309, 5311, 5313, 5315, + 5317, 5319, 5321, 5323, 5325, 5327, 5329, 5331, 5333, 5335, + 5337, 5339, 5341, 5343, 5345, 5347, 5349, 5351, 5353, 5355, + 5357, 5359, 5361, 5363, 5365, 5367, 5369, 5371, 5373, 5375, + 5377, 5379, 5381, 5383, 5385, 5387, 5389, 5391, 5393, 5395, + 5397, 5399, 5401, 5403, 5405, 5407, 5409, 5411, 5413, 5415, + 5417, 5419, 5421, 5423, 5425, 5427, 5429, 5431, 5433, 5435, + 5437, 5439, 5441, 5443, 5445, 5447, 5449, 5451, 5453, 5455, + 5457, 5459, 5461, 5463, 5465, 5467, 5469, 5471, 5473, 5475, + 5477, 5479, 5481, 5483, 5485, 5487, 5489, 5491, 5493, 5495, + 5497, 5499, 5501, 5503, 5505, 5507, 5509, 5511, 5513, 5515, + 5517, 5519, 5521, 5523, 5525, 5527, 5529, 5531, 5533, 5535, + 5537, 5539, 5541, 5543, 5545, 5547, 5549, 5551, 5553, 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 }; /* YYRHS -- A `-1'-separated list of the rules' RHS. */ @@ -2318,295 +2318,296 @@ static const yytype_int16 yyrhs[] = 831, -1, 839, -1, 39, 687, -1, 39, 516, 874, 517, -1, 526, 9, -1, 516, 874, 517, -1, 527, 858, 528, -1, 247, 527, 862, 528, -1, 924, 518, - 519, -1, 924, 518, 711, 519, -1, 924, 518, 875, - 710, 709, 519, -1, 924, 518, 466, 876, 710, 709, - 519, -1, 924, 518, 875, 522, 466, 876, 710, 709, - 519, -1, 924, 518, 30, 875, 710, 709, 519, -1, - 924, 518, 132, 875, 710, 709, 519, -1, 834, 840, - 841, 842, 846, -1, 837, -1, 834, -1, 837, -1, - 81, 167, 518, 824, 519, -1, 66, 518, 824, 40, - 788, 519, -1, 441, 518, 824, 40, 788, 519, -1, - 159, 518, 878, 519, -1, 303, 518, 880, 519, -1, - 321, 518, 882, 519, -1, 414, 518, 883, 519, -1, - 435, 518, 824, 40, 788, 519, -1, 437, 518, 58, - 886, 519, -1, 437, 518, 233, 886, 519, -1, 437, - 518, 432, 886, 519, -1, 437, 518, 886, 519, -1, - 281, 518, 824, 522, 824, 519, -1, 79, 518, 873, - 519, -1, 893, -1, 516, 824, 167, 838, 199, 824, - 517, -1, 516, 824, 167, 838, 199, 826, 192, 824, - 517, -1, 481, 181, 518, 711, 519, -1, -1, 163, - 518, 477, 824, 519, -1, 163, 518, 824, 519, -1, - -1, 155, -1, -1, 479, 844, -1, -1, 845, -1, - 844, 522, 845, -1, 546, 40, 847, -1, 301, 847, - -1, 301, 546, -1, -1, 518, 848, 849, 710, 850, - 519, -1, 546, -1, -1, 310, 59, 872, -1, -1, - 340, 851, 853, -1, 369, 851, 853, -1, 184, 851, - 853, -1, -1, 852, -1, 53, 852, 36, 852, -1, - 444, 324, -1, 444, 166, -1, 104, 368, -1, 824, - 324, -1, 824, 166, -1, 148, 104, 368, -1, 148, - 181, -1, 148, 428, -1, 148, 273, 298, -1, -1, - 368, 518, 873, 519, -1, 368, 518, 519, -1, 854, - -1, 518, 872, 522, 824, 519, -1, 547, 523, 824, - -1, 856, -1, 857, 522, 856, -1, 857, -1, 857, - 522, -1, 824, 523, 824, -1, 859, -1, 860, 522, - 859, -1, 860, -1, 860, 522, -1, 861, -1, -1, - 38, -1, 399, -1, 30, -1, 8, -1, 865, -1, - 509, -1, 510, -1, 511, -1, 512, -1, 15, -1, - 513, -1, 514, -1, 16, -1, 505, -1, 506, -1, - 507, -1, 19, -1, 20, -1, 21, -1, 8, -1, - 292, 518, 869, 519, -1, 864, -1, 292, 518, 869, - 519, -1, 864, -1, 292, 518, 869, 519, -1, 237, - -1, 502, 237, -1, 177, -1, 502, 177, -1, 194, - -1, 502, 194, -1, 864, -1, 546, 520, 869, -1, - 826, -1, 870, 522, 826, -1, 870, -1, 870, 522, - -1, 824, -1, 872, 522, 824, -1, 872, -1, 872, - 522, -1, 873, -1, -1, 876, -1, 875, 522, 876, - -1, 824, -1, 933, 13, 824, -1, 933, 14, 824, - -1, 788, -1, 877, 522, 788, -1, 879, 172, 824, - -1, -1, 3, -1, 810, -1, 811, -1, 812, -1, - 813, -1, 814, -1, 815, -1, 816, -1, 817, -1, - 818, -1, 819, -1, 820, -1, 821, -1, 822, -1, - 548, -1, 824, 881, 884, 885, -1, 824, 881, 884, - -1, 318, 824, -1, 825, 199, 825, -1, -1, 824, - 884, 885, -1, 824, 885, 884, -1, 824, 884, -1, - 824, 885, -1, 872, -1, -1, 172, 824, -1, 167, - 824, -1, 824, 172, 873, -1, 172, 873, -1, 873, - -1, 687, -1, 518, 873, 519, -1, 895, -1, 830, - -1, 65, 892, 889, 891, 143, -1, 890, -1, 889, - 890, -1, 476, 824, 427, 824, -1, 139, 824, -1, - -1, 824, -1, -1, 894, -1, 893, 522, 894, -1, - 546, -1, 546, -1, 546, 549, -1, 516, 824, 517, - -1, 516, 896, 523, 896, 517, -1, 516, 896, 523, - 896, 523, 896, 517, -1, 516, 896, 523, 510, 523, - 896, 517, -1, 824, -1, -1, -1, 897, 550, -1, - -1, 518, 519, -1, 518, 875, 519, -1, 520, 551, - 898, -1, 516, 824, 517, -1, 516, 896, 523, 896, - 517, -1, 516, 896, 523, 896, 523, 896, 517, -1, - 516, 896, 523, 510, 523, 896, 517, -1, -1, 900, - 899, -1, 45, -1, -1, 904, -1, -1, 905, -1, - 903, 522, 905, -1, 903, -1, 903, 522, -1, 824, - 40, 934, -1, 824, 3, -1, 824, -1, 546, 523, - 824, -1, 148, 518, 909, 519, -1, 148, 907, -1, - 547, -1, 907, 520, 547, -1, 907, -1, 908, 522, - 907, -1, 908, -1, 908, 522, -1, 906, -1, -1, - 824, 40, 546, -1, 911, -1, 912, 522, 911, -1, - 912, -1, 912, 522, -1, 355, 518, 913, 519, -1, - 355, 911, -1, -1, 907, 40, 546, -1, 915, -1, - 916, 522, 915, -1, 916, -1, 916, 522, -1, 353, - 518, 917, 519, -1, 353, 915, -1, -1, 545, -1, - 919, 522, 545, -1, 923, -1, 920, 522, 923, -1, - 920, -1, 920, 522, -1, 921, -1, 518, 921, 519, - -1, 547, -1, 928, -1, 546, 549, -1, 926, -1, - 4, -1, 548, 897, -1, 6, -1, 7, -1, 924, - 548, -1, 924, 518, 875, 710, 709, 519, 548, -1, - 792, 548, -1, 808, 518, 824, 519, 823, -1, 808, - 926, 823, -1, 808, 548, 823, -1, 438, -1, 160, - -1, 280, -1, 9, -1, 3, -1, 1005, -1, 1010, - -1, 3, -1, 1005, -1, 1007, -1, 3, -1, 1005, - -1, 1008, -1, 546, -1, 546, 931, -1, 520, 551, - -1, 931, 520, 551, -1, 518, 921, 519, -1, -1, - 927, -1, 552, -1, 5, -1, 326, 923, 936, 40, - 937, -1, 518, 877, 519, -1, -1, 686, -1, 555, - -1, 667, -1, 668, -1, 982, -1, 994, -1, 100, - 373, 545, 939, -1, 100, 373, 192, 275, 152, 545, - 939, -1, 100, 295, 355, 373, 545, 939, -1, 939, - 940, -1, -1, 604, -1, 941, -1, 580, -1, 1000, - -1, 100, 947, 203, 944, 945, 290, 545, 943, 518, - 574, 519, 946, 781, -1, 100, 947, 203, 944, 192, - 275, 152, 633, 290, 545, 943, 518, 574, 519, 946, - 781, -1, 546, -1, 457, 942, -1, -1, 89, -1, - -1, 633, -1, -1, 480, 619, -1, -1, 448, -1, - -1, 32, 419, 775, 389, 373, 923, -1, 32, 419, - 192, 152, 775, 389, 373, 923, -1, 32, 384, 545, - 389, 373, 923, -1, 32, 384, 192, 152, 545, 389, - 373, 923, -1, 32, 470, 545, 389, 373, 923, -1, - 32, 470, 192, 152, 545, 389, 373, 923, -1, 168, - 75, 950, -1, 75, 950, -1, 546, -1, -1, 84, - 290, 953, 545, 222, 952, -1, 84, 290, 82, 824, - 222, 952, -1, 548, -1, 280, -1, 419, -1, 384, - -1, 174, -1, 246, -1, 246, 419, -1, 470, -1, - 108, -1, 203, -1, 373, -1, 442, -1, 154, 108, - 548, 676, -1, 154, 108, 546, 431, 548, 676, -1, - 198, 108, 548, -1, 153, 959, -1, 153, 963, 957, - 959, -1, 153, 468, 959, -1, 153, 518, 962, 519, - 959, -1, 468, -1, -1, 964, -1, 594, -1, -1, - 948, -1, 591, -1, 533, -1, 999, -1, 949, -1, - 668, -1, 1002, -1, 658, -1, 938, -1, 580, -1, - 604, -1, 576, -1, 544, -1, 982, -1, 652, -1, - 587, -1, 941, -1, 555, -1, 973, -1, 579, -1, - 935, -1, 553, -1, 686, -1, 600, -1, 667, -1, - 586, -1, 977, -1, 991, -1, 967, -1, 994, -1, - 1000, -1, 3, -1, 1005, -1, 1009, -1, 960, -1, - 548, -1, 965, -1, 962, 522, 965, -1, 35, -1, - 34, -1, 438, -1, 160, -1, 290, -1, 961, -1, - 966, 958, -1, 960, -1, 963, -1, 389, 968, -1, - 389, 241, 968, -1, 389, 388, 968, -1, 389, 178, - 968, -1, 389, 465, 968, -1, 969, -1, 998, 172, - 104, -1, 429, 501, 971, -1, 373, 548, -1, 998, - 431, 972, -1, 998, 507, 972, -1, 824, -1, 548, - -1, 3, -1, 808, 548, 823, -1, 808, 518, 926, - 519, 548, -1, 594, -1, 117, -1, 241, -1, 970, - -1, 972, 522, 970, -1, 240, 975, -1, 974, 214, - 975, 976, -1, 974, 214, 975, 172, 546, 976, -1, - 974, 214, 975, 172, 548, 976, -1, -1, 168, -1, - 548, -1, 546, -1, -1, 469, 548, -1, 469, 546, - -1, 458, 979, 981, 957, -1, 458, 979, 981, 957, - 545, 932, -1, 458, 979, 981, 957, 986, -1, 458, - 518, 980, 519, -1, 458, 518, 980, 519, 545, 932, - -1, 963, -1, 468, -1, 171, -1, 173, -1, 3, - -1, 173, -1, -1, 978, -1, 980, 522, 978, -1, - 171, -1, -1, 560, 122, 172, 983, 985, 984, 566, - -1, 439, 704, 983, -1, 775, -1, 775, 546, -1, - 775, 40, 546, -1, 477, 824, -1, -1, 457, 756, - -1, -1, 963, 957, -1, 963, 957, 545, 932, -1, - 47, 989, 548, 990, 676, -1, 47, 192, 275, 152, - 989, 548, 990, 676, -1, 128, 552, -1, 128, 108, - 552, -1, 128, 108, 192, 152, 552, -1, 108, -1, - -1, 40, 546, -1, -1, 357, 993, -1, 357, 241, - 993, -1, 357, 388, 993, -1, 357, 178, 993, -1, - 357, 465, 993, -1, 998, -1, 30, -1, 992, -1, - 429, 501, -1, 433, 224, 236, -1, 996, 686, -1, - 415, 686, -1, 415, 545, -1, 996, 545, -1, 996, - 429, 501, -1, 996, 433, 224, 236, -1, 996, 30, - 997, -1, 996, -1, 127, -1, 126, -1, 393, -1, - 995, -1, 420, -1, -1, 546, -1, 998, 520, 546, - -1, 61, 834, -1, 100, 650, 470, 545, 639, 946, - 40, 686, 1001, -1, 100, 650, 470, 192, 275, 152, - 545, 639, 946, 40, 686, 1001, -1, 100, 295, 355, - 650, 470, 545, 639, 946, 40, 686, 1001, -1, 100, - 650, 345, 470, 545, 518, 643, 519, 946, 40, 686, - 1001, -1, 100, 295, 355, 650, 345, 470, 545, 518, - 643, 519, 946, 40, 686, 1001, -1, 480, 74, 293, - -1, 480, 64, 74, 293, -1, 480, 241, 74, 293, - -1, -1, 100, 650, 419, 1004, 40, 686, 1003, -1, - 100, 650, 419, 192, 275, 152, 1004, 40, 686, 1003, - -1, 100, 295, 355, 650, 419, 1004, 40, 686, 1003, - -1, 480, 107, -1, 480, 273, 107, -1, -1, 545, - 639, 626, 618, -1, 22, -1, 23, -1, 24, -1, - 25, -1, 26, -1, 27, -1, 28, -1, 29, -1, - 31, -1, 32, -1, 33, -1, 43, -1, 44, -1, - 46, -1, 47, -1, 48, -1, 50, -1, 51, -1, - 52, -1, 59, -1, 60, -1, 61, -1, 62, -1, - 63, -1, 64, -1, 67, -1, 68, -1, 69, -1, - 70, -1, 73, -1, 75, -1, 76, -1, 77, -1, - 78, -1, 84, -1, 85, -1, 86, -1, 87, -1, - 88, -1, 90, -1, 91, -1, 92, -1, 94, -1, - 95, -1, 96, -1, 97, -1, 98, -1, 99, -1, - 102, -1, 103, -1, 104, -1, 105, -1, 106, -1, - 107, -1, 108, -1, 109, -1, 110, -1, 111, -1, - 113, -1, 114, -1, 116, -1, 118, -1, 120, -1, - 121, -1, 122, -1, 123, -1, 124, -1, 125, -1, - 128, -1, 129, -1, 130, -1, 131, -1, 134, -1, - 135, -1, 136, -1, 137, -1, 138, -1, 140, -1, - 141, -1, 142, -1, 144, -1, 145, -1, 146, -1, - 148, -1, 149, -1, 150, -1, 151, -1, 153, -1, - 154, -1, 155, -1, 156, -1, 157, -1, 158, -1, - 161, -1, 163, -1, 164, -1, 166, -1, 168, -1, - 170, -1, 174, -1, 175, -1, 178, -1, 180, -1, - 184, -1, 185, -1, 187, -1, 188, -1, 189, -1, - 190, -1, 191, -1, 192, -1, 193, -1, 195, -1, - 196, -1, 197, -1, 198, -1, 200, -1, 201, -1, - 202, -1, 203, -1, 204, -1, 205, -1, 206, -1, - 208, -1, 211, -1, 212, -1, 213, -1, 214, -1, - 215, -1, 221, -1, 224, -1, 226, -1, 227, -1, - 228, -1, 229, -1, 230, -1, 231, -1, 234, -1, - 236, -1, 239, -1, 240, -1, 241, -1, 242, -1, - 243, -1, 244, -1, 245, -1, 246, -1, 248, -1, - 249, -1, 250, -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, 271, -1, - 272, -1, 273, -1, 276, -1, 277, -1, 279, -1, - 282, -1, 284, -1, 285, -1, 286, -1, 288, -1, - 289, -1, 292, -1, 293, -1, 294, -1, 297, -1, - 298, -1, 301, -1, 304, -1, 305, -1, 306, -1, - 307, -1, 308, -1, 309, -1, 310, -1, 311, -1, - 312, -1, 313, -1, 314, -1, 319, -1, 320, -1, - 323, -1, 324, -1, 326, -1, 327, -1, 328, -1, - 330, -1, 331, -1, 332, -1, 333, -1, 334, -1, - 335, -1, 337, -1, 338, -1, 339, -1, 340, -1, - 341, -1, 343, -1, 344, -1, 345, -1, 346, -1, - 348, -1, 349, -1, 350, -1, 351, -1, 352, -1, - 353, -1, 354, -1, 355, -1, 356, -1, 357, -1, - 358, -1, 359, -1, 360, -1, 362, -1, 363, -1, - 365, -1, 366, -1, 367, -1, 369, -1, 370, -1, - 371, -1, 372, -1, 373, -1, 374, -1, 375, -1, - 376, -1, 377, -1, 378, -1, 379, -1, 380, -1, - 381, -1, 384, -1, 385, -1, 386, -1, 387, -1, - 388, -1, 389, -1, 391, -1, 392, -1, 395, -1, - 396, -1, 398, -1, 400, -1, 401, -1, 402, -1, - 403, -1, 404, -1, 405, -1, 406, -1, 407, -1, - 408, -1, 409, -1, 410, -1, 411, -1, 413, -1, - 417, -1, 418, -1, 420, -1, 422, -1, 423, -1, - 424, -1, 425, -1, 426, -1, 428, -1, 433, -1, - 434, -1, 436, -1, 439, -1, 440, -1, 442, -1, - 443, -1, 444, -1, 445, -1, 446, -1, 449, -1, - 450, -1, 451, -1, 453, -1, 454, -1, 455, -1, - 456, -1, 458, -1, 459, -1, 460, -1, 461, -1, - 462, -1, 465, -1, 467, -1, 469, -1, 470, -1, - 471, -1, 472, -1, 473, -1, 474, -1, 475, -1, - 478, -1, 481, -1, 482, -1, 483, -1, 484, -1, - 485, -1, 486, -1, 498, -1, 499, -1, 500, -1, - 501, -1, 53, -1, 54, -1, 56, -1, 57, -1, - 71, -1, 72, -1, 79, -1, 83, -1, 112, -1, - 115, -1, 152, -1, 159, -1, 165, -1, 176, -1, - 182, -1, 183, -1, 210, -1, 216, -1, 217, -1, - 219, -1, 247, -1, 268, -1, 270, -1, 274, -1, - 281, -1, 283, -1, 299, -1, 303, -1, 321, -1, - 325, -1, 342, -1, 368, -1, 390, -1, 397, -1, - 412, -1, 414, -1, 429, -1, 430, -1, 435, -1, - 437, -1, 441, -1, 463, -1, 464, -1, 487, -1, - 488, -1, 489, -1, 490, -1, 491, -1, 492, -1, - 493, -1, 494, -1, 495, -1, 496, -1, 497, -1, - 42, -1, 49, -1, 55, -1, 81, -1, 89, -1, - 101, -1, 171, -1, 173, -1, 176, -1, 177, -1, - 194, -1, 209, -1, 222, -1, 223, -1, 225, -1, - 235, -1, 237, -1, 247, -1, 269, -1, 278, -1, - 300, -1, 302, -1, 322, -1, 364, -1, 394, -1, - 412, -1, 421, -1, 468, -1, 37, -1, 42, -1, - 49, -1, 55, -1, 81, -1, 83, -1, 89, -1, - 101, -1, 171, -1, 173, -1, 177, -1, 194, -1, - 209, -1, 222, -1, 223, -1, 225, -1, 235, -1, - 237, -1, 269, -1, 278, -1, 300, -1, 302, -1, - 322, -1, 364, -1, 383, -1, 394, -1, 421, -1, - 441, -1, 468, -1, 37, -1, 42, -1, 49, -1, - 53, -1, 54, -1, 55, -1, 56, -1, 57, -1, - 72, -1, 71, -1, 79, -1, 81, -1, 83, -1, - 89, -1, 101, -1, 112, -1, 115, -1, 152, -1, - 159, -1, 165, -1, 171, -1, 173, -1, 176, -1, - 177, -1, 182, -1, 183, -1, 194, -1, 209, -1, - 210, -1, 217, -1, 219, -1, 216, -1, 222, -1, - 223, -1, 225, -1, 235, -1, 237, -1, 247, -1, - 268, -1, 269, -1, 270, -1, 274, -1, 278, -1, - 281, -1, 283, -1, 300, -1, 299, -1, 302, -1, - 303, -1, 321, -1, 322, -1, 325, -1, 342, -1, - 364, -1, 368, -1, 383, -1, 390, -1, 394, -1, - 397, -1, 412, -1, 414, -1, 421, -1, 429, -1, - 430, -1, 435, -1, 437, -1, 441, -1, 463, -1, - 464, -1, 468, -1, 487, -1, 488, -1, 489, -1, - 490, -1, 491, -1, 492, -1, 493, -1, 494, -1, - 495, -1, 496, -1, 497, -1, 37, -1, 42, -1, - 49, -1, 55, -1, 81, -1, 83, -1, 89, -1, - 101, -1, 171, -1, 173, -1, 176, -1, 177, -1, - 194, -1, 209, -1, 222, -1, 223, -1, 225, -1, - 235, -1, 237, -1, 247, -1, 269, -1, 278, -1, - 300, -1, 302, -1, 322, -1, 364, -1, 383, -1, - 394, -1, 412, -1, 421, -1, 441, -1, 468, -1, - 30, -1, 34, -1, 35, -1, 36, -1, 38, -1, - 39, -1, 40, -1, 41, -1, 45, -1, 58, -1, - 65, -1, 66, -1, 74, -1, 80, -1, 82, -1, - 93, -1, 100, -1, 117, -1, 119, -1, 126, -1, - 127, -1, 132, -1, 133, -1, 139, -1, 143, -1, - 147, -1, 160, -1, 162, -1, 167, -1, 169, -1, - 172, -1, 179, -1, 181, -1, 186, -1, 199, -1, - 207, -1, 218, -1, 220, -1, 232, -1, 233, -1, - 238, -1, 275, -1, 280, -1, 287, -1, 290, -1, - 291, -1, 295, -1, 296, -1, 315, -1, 316, -1, - 317, -1, 318, -1, 329, -1, 336, -1, 347, -1, - 361, -1, 382, -1, 393, -1, 399, -1, 415, -1, - 416, -1, 419, -1, 427, -1, 431, -1, 432, -1, - 438, -1, 447, -1, 448, -1, 452, -1, 457, -1, - 466, -1, 476, -1, 477, -1, 479, -1, 480, -1 + 519, -1, 924, 518, 711, 709, 519, -1, 924, 518, + 875, 710, 709, 519, -1, 924, 518, 466, 876, 710, + 709, 519, -1, 924, 518, 875, 522, 466, 876, 710, + 709, 519, -1, 924, 518, 30, 875, 710, 709, 519, + -1, 924, 518, 132, 875, 710, 709, 519, -1, 834, + 840, 841, 842, 846, -1, 837, -1, 834, -1, 837, + -1, 81, 167, 518, 824, 519, -1, 66, 518, 824, + 40, 788, 519, -1, 441, 518, 824, 40, 788, 519, + -1, 159, 518, 878, 519, -1, 303, 518, 880, 519, + -1, 321, 518, 882, 519, -1, 414, 518, 883, 519, + -1, 435, 518, 824, 40, 788, 519, -1, 437, 518, + 58, 886, 519, -1, 437, 518, 233, 886, 519, -1, + 437, 518, 432, 886, 519, -1, 437, 518, 886, 519, + -1, 281, 518, 824, 522, 824, 519, -1, 79, 518, + 873, 519, -1, 893, -1, 516, 824, 167, 838, 199, + 824, 517, -1, 516, 824, 167, 838, 199, 826, 192, + 824, 517, -1, 481, 181, 518, 711, 519, -1, -1, + 163, 518, 477, 824, 519, -1, 163, 518, 824, 519, + -1, -1, 155, -1, -1, 479, 844, -1, -1, 845, + -1, 844, 522, 845, -1, 546, 40, 847, -1, 301, + 847, -1, 301, 546, -1, -1, 518, 848, 849, 710, + 850, 519, -1, 546, -1, -1, 310, 59, 872, -1, + -1, 340, 851, 853, -1, 369, 851, 853, -1, 184, + 851, 853, -1, -1, 852, -1, 53, 852, 36, 852, + -1, 444, 324, -1, 444, 166, -1, 104, 368, -1, + 824, 324, -1, 824, 166, -1, 148, 104, 368, -1, + 148, 181, -1, 148, 428, -1, 148, 273, 298, -1, + -1, 368, 518, 873, 519, -1, 368, 518, 519, -1, + 854, -1, 518, 872, 522, 824, 519, -1, 547, 523, + 824, -1, 856, -1, 857, 522, 856, -1, 857, -1, + 857, 522, -1, 824, 523, 824, -1, 859, -1, 860, + 522, 859, -1, 860, -1, 860, 522, -1, 861, -1, + -1, 38, -1, 399, -1, 30, -1, 8, -1, 865, + -1, 509, -1, 510, -1, 511, -1, 512, -1, 15, + -1, 513, -1, 514, -1, 16, -1, 505, -1, 506, + -1, 507, -1, 19, -1, 20, -1, 21, -1, 8, + -1, 292, 518, 869, 519, -1, 864, -1, 292, 518, + 869, 519, -1, 864, -1, 292, 518, 869, 519, -1, + 237, -1, 502, 237, -1, 177, -1, 502, 177, -1, + 194, -1, 502, 194, -1, 864, -1, 546, 520, 869, + -1, 826, -1, 870, 522, 826, -1, 870, -1, 870, + 522, -1, 824, -1, 872, 522, 824, -1, 872, -1, + 872, 522, -1, 873, -1, -1, 876, -1, 875, 522, + 876, -1, 824, -1, 933, 13, 824, -1, 933, 14, + 824, -1, 788, -1, 877, 522, 788, -1, 879, 172, + 824, -1, -1, 3, -1, 810, -1, 811, -1, 812, + -1, 813, -1, 814, -1, 815, -1, 816, -1, 817, + -1, 818, -1, 819, -1, 820, -1, 821, -1, 822, + -1, 548, -1, 824, 881, 884, 885, -1, 824, 881, + 884, -1, 318, 824, -1, 825, 199, 825, -1, -1, + 824, 884, 885, -1, 824, 885, 884, -1, 824, 884, + -1, 824, 885, -1, 872, -1, -1, 172, 824, -1, + 167, 824, -1, 824, 172, 873, -1, 172, 873, -1, + 873, -1, 687, -1, 518, 873, 519, -1, 895, -1, + 830, -1, 65, 892, 889, 891, 143, -1, 890, -1, + 889, 890, -1, 476, 824, 427, 824, -1, 139, 824, + -1, -1, 824, -1, -1, 894, -1, 893, 522, 894, + -1, 546, -1, 546, -1, 546, 549, -1, 516, 824, + 517, -1, 516, 896, 523, 896, 517, -1, 516, 896, + 523, 896, 523, 896, 517, -1, 516, 896, 523, 510, + 523, 896, 517, -1, 824, -1, -1, -1, 897, 550, + -1, -1, 518, 519, -1, 518, 875, 519, -1, 520, + 551, 898, -1, 516, 824, 517, -1, 516, 896, 523, + 896, 517, -1, 516, 896, 523, 896, 523, 896, 517, + -1, 516, 896, 523, 510, 523, 896, 517, -1, -1, + 900, 899, -1, 45, -1, -1, 904, -1, -1, 905, + -1, 903, 522, 905, -1, 903, -1, 903, 522, -1, + 824, 40, 934, -1, 824, 3, -1, 824, -1, 546, + 523, 824, -1, 148, 518, 909, 519, -1, 148, 907, + -1, 547, -1, 907, 520, 547, -1, 907, -1, 908, + 522, 907, -1, 908, -1, 908, 522, -1, 906, -1, + -1, 824, 40, 546, -1, 911, -1, 912, 522, 911, + -1, 912, -1, 912, 522, -1, 355, 518, 913, 519, + -1, 355, 911, -1, -1, 907, 40, 546, -1, 915, + -1, 916, 522, 915, -1, 916, -1, 916, 522, -1, + 353, 518, 917, 519, -1, 353, 915, -1, -1, 545, + -1, 919, 522, 545, -1, 923, -1, 920, 522, 923, + -1, 920, -1, 920, 522, -1, 921, -1, 518, 921, + 519, -1, 547, -1, 928, -1, 546, 549, -1, 926, + -1, 4, -1, 548, 897, -1, 6, -1, 7, -1, + 924, 548, -1, 924, 518, 875, 710, 709, 519, 548, + -1, 792, 548, -1, 808, 518, 824, 519, 823, -1, + 808, 926, 823, -1, 808, 548, 823, -1, 438, -1, + 160, -1, 280, -1, 9, -1, 3, -1, 1005, -1, + 1010, -1, 3, -1, 1005, -1, 1007, -1, 3, -1, + 1005, -1, 1008, -1, 546, -1, 546, 931, -1, 520, + 551, -1, 931, 520, 551, -1, 518, 921, 519, -1, + -1, 927, -1, 552, -1, 5, -1, 326, 923, 936, + 40, 937, -1, 518, 877, 519, -1, -1, 686, -1, + 555, -1, 667, -1, 668, -1, 982, -1, 994, -1, + 100, 373, 545, 939, -1, 100, 373, 192, 275, 152, + 545, 939, -1, 100, 295, 355, 373, 545, 939, -1, + 939, 940, -1, -1, 604, -1, 941, -1, 580, -1, + 1000, -1, 100, 947, 203, 944, 945, 290, 545, 943, + 518, 574, 519, 946, 781, -1, 100, 947, 203, 944, + 192, 275, 152, 633, 290, 545, 943, 518, 574, 519, + 946, 781, -1, 546, -1, 457, 942, -1, -1, 89, + -1, -1, 633, -1, -1, 480, 619, -1, -1, 448, + -1, -1, 32, 419, 775, 389, 373, 923, -1, 32, + 419, 192, 152, 775, 389, 373, 923, -1, 32, 384, + 545, 389, 373, 923, -1, 32, 384, 192, 152, 545, + 389, 373, 923, -1, 32, 470, 545, 389, 373, 923, + -1, 32, 470, 192, 152, 545, 389, 373, 923, -1, + 168, 75, 950, -1, 75, 950, -1, 546, -1, -1, + 84, 290, 953, 545, 222, 952, -1, 84, 290, 82, + 824, 222, 952, -1, 548, -1, 280, -1, 419, -1, + 384, -1, 174, -1, 246, -1, 246, 419, -1, 470, + -1, 108, -1, 203, -1, 373, -1, 442, -1, 154, + 108, 548, 676, -1, 154, 108, 546, 431, 548, 676, + -1, 198, 108, 548, -1, 153, 959, -1, 153, 963, + 957, 959, -1, 153, 468, 959, -1, 153, 518, 962, + 519, 959, -1, 468, -1, -1, 964, -1, 594, -1, + -1, 948, -1, 591, -1, 533, -1, 999, -1, 949, + -1, 668, -1, 1002, -1, 658, -1, 938, -1, 580, + -1, 604, -1, 576, -1, 544, -1, 982, -1, 652, + -1, 587, -1, 941, -1, 555, -1, 973, -1, 579, + -1, 935, -1, 553, -1, 686, -1, 600, -1, 667, + -1, 586, -1, 977, -1, 991, -1, 967, -1, 994, + -1, 1000, -1, 3, -1, 1005, -1, 1009, -1, 960, + -1, 548, -1, 965, -1, 962, 522, 965, -1, 35, + -1, 34, -1, 438, -1, 160, -1, 290, -1, 961, + -1, 966, 958, -1, 960, -1, 963, -1, 389, 968, + -1, 389, 241, 968, -1, 389, 388, 968, -1, 389, + 178, 968, -1, 389, 465, 968, -1, 969, -1, 998, + 172, 104, -1, 429, 501, 971, -1, 373, 548, -1, + 998, 431, 972, -1, 998, 507, 972, -1, 824, -1, + 548, -1, 3, -1, 808, 548, 823, -1, 808, 518, + 926, 519, 548, -1, 594, -1, 117, -1, 241, -1, + 970, -1, 972, 522, 970, -1, 240, 975, -1, 974, + 214, 975, 976, -1, 974, 214, 975, 172, 546, 976, + -1, 974, 214, 975, 172, 548, 976, -1, -1, 168, + -1, 548, -1, 546, -1, -1, 469, 548, -1, 469, + 546, -1, 458, 979, 981, 957, -1, 458, 979, 981, + 957, 545, 932, -1, 458, 979, 981, 957, 986, -1, + 458, 518, 980, 519, -1, 458, 518, 980, 519, 545, + 932, -1, 963, -1, 468, -1, 171, -1, 173, -1, + 3, -1, 173, -1, -1, 978, -1, 980, 522, 978, + -1, 171, -1, -1, 560, 122, 172, 983, 985, 984, + 566, -1, 439, 704, 983, -1, 775, -1, 775, 546, + -1, 775, 40, 546, -1, 477, 824, -1, -1, 457, + 756, -1, -1, 963, 957, -1, 963, 957, 545, 932, + -1, 47, 989, 548, 990, 676, -1, 47, 192, 275, + 152, 989, 548, 990, 676, -1, 128, 552, -1, 128, + 108, 552, -1, 128, 108, 192, 152, 552, -1, 108, + -1, -1, 40, 546, -1, -1, 357, 993, -1, 357, + 241, 993, -1, 357, 388, 993, -1, 357, 178, 993, + -1, 357, 465, 993, -1, 998, -1, 30, -1, 992, + -1, 429, 501, -1, 433, 224, 236, -1, 996, 686, + -1, 415, 686, -1, 415, 545, -1, 996, 545, -1, + 996, 429, 501, -1, 996, 433, 224, 236, -1, 996, + 30, 997, -1, 996, -1, 127, -1, 126, -1, 393, + -1, 995, -1, 420, -1, -1, 546, -1, 998, 520, + 546, -1, 61, 834, -1, 100, 650, 470, 545, 639, + 946, 40, 686, 1001, -1, 100, 650, 470, 192, 275, + 152, 545, 639, 946, 40, 686, 1001, -1, 100, 295, + 355, 650, 470, 545, 639, 946, 40, 686, 1001, -1, + 100, 650, 345, 470, 545, 518, 643, 519, 946, 40, + 686, 1001, -1, 100, 295, 355, 650, 345, 470, 545, + 518, 643, 519, 946, 40, 686, 1001, -1, 480, 74, + 293, -1, 480, 64, 74, 293, -1, 480, 241, 74, + 293, -1, -1, 100, 650, 419, 1004, 40, 686, 1003, + -1, 100, 650, 419, 192, 275, 152, 1004, 40, 686, + 1003, -1, 100, 295, 355, 650, 419, 1004, 40, 686, + 1003, -1, 480, 107, -1, 480, 273, 107, -1, -1, + 545, 639, 626, 618, -1, 22, -1, 23, -1, 24, + -1, 25, -1, 26, -1, 27, -1, 28, -1, 29, + -1, 31, -1, 32, -1, 33, -1, 43, -1, 44, + -1, 46, -1, 47, -1, 48, -1, 50, -1, 51, + -1, 52, -1, 59, -1, 60, -1, 61, -1, 62, + -1, 63, -1, 64, -1, 67, -1, 68, -1, 69, + -1, 70, -1, 73, -1, 75, -1, 76, -1, 77, + -1, 78, -1, 84, -1, 85, -1, 86, -1, 87, + -1, 88, -1, 90, -1, 91, -1, 92, -1, 94, + -1, 95, -1, 96, -1, 97, -1, 98, -1, 99, + -1, 102, -1, 103, -1, 104, -1, 105, -1, 106, + -1, 107, -1, 108, -1, 109, -1, 110, -1, 111, + -1, 113, -1, 114, -1, 116, -1, 118, -1, 120, + -1, 121, -1, 122, -1, 123, -1, 124, -1, 125, + -1, 128, -1, 129, -1, 130, -1, 131, -1, 134, + -1, 135, -1, 136, -1, 137, -1, 138, -1, 140, + -1, 141, -1, 142, -1, 144, -1, 145, -1, 146, + -1, 148, -1, 149, -1, 150, -1, 151, -1, 153, + -1, 154, -1, 155, -1, 156, -1, 157, -1, 158, + -1, 161, -1, 163, -1, 164, -1, 166, -1, 168, + -1, 170, -1, 174, -1, 175, -1, 178, -1, 180, + -1, 184, -1, 185, -1, 187, -1, 188, -1, 189, + -1, 190, -1, 191, -1, 192, -1, 193, -1, 195, + -1, 196, -1, 197, -1, 198, -1, 200, -1, 201, + -1, 202, -1, 203, -1, 204, -1, 205, -1, 206, + -1, 208, -1, 211, -1, 212, -1, 213, -1, 214, + -1, 215, -1, 221, -1, 224, -1, 226, -1, 227, + -1, 228, -1, 229, -1, 230, -1, 231, -1, 234, + -1, 236, -1, 239, -1, 240, -1, 241, -1, 242, + -1, 243, -1, 244, -1, 245, -1, 246, -1, 248, + -1, 249, -1, 250, -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, 271, + -1, 272, -1, 273, -1, 276, -1, 277, -1, 279, + -1, 282, -1, 284, -1, 285, -1, 286, -1, 288, + -1, 289, -1, 292, -1, 293, -1, 294, -1, 297, + -1, 298, -1, 301, -1, 304, -1, 305, -1, 306, + -1, 307, -1, 308, -1, 309, -1, 310, -1, 311, + -1, 312, -1, 313, -1, 314, -1, 319, -1, 320, + -1, 323, -1, 324, -1, 326, -1, 327, -1, 328, + -1, 330, -1, 331, -1, 332, -1, 333, -1, 334, + -1, 335, -1, 337, -1, 338, -1, 339, -1, 340, + -1, 341, -1, 343, -1, 344, -1, 345, -1, 346, + -1, 348, -1, 349, -1, 350, -1, 351, -1, 352, + -1, 353, -1, 354, -1, 355, -1, 356, -1, 357, + -1, 358, -1, 359, -1, 360, -1, 362, -1, 363, + -1, 365, -1, 366, -1, 367, -1, 369, -1, 370, + -1, 371, -1, 372, -1, 373, -1, 374, -1, 375, + -1, 376, -1, 377, -1, 378, -1, 379, -1, 380, + -1, 381, -1, 384, -1, 385, -1, 386, -1, 387, + -1, 388, -1, 389, -1, 391, -1, 392, -1, 395, + -1, 396, -1, 398, -1, 400, -1, 401, -1, 402, + -1, 403, -1, 404, -1, 405, -1, 406, -1, 407, + -1, 408, -1, 409, -1, 410, -1, 411, -1, 413, + -1, 417, -1, 418, -1, 420, -1, 422, -1, 423, + -1, 424, -1, 425, -1, 426, -1, 428, -1, 433, + -1, 434, -1, 436, -1, 439, -1, 440, -1, 442, + -1, 443, -1, 444, -1, 445, -1, 446, -1, 449, + -1, 450, -1, 451, -1, 453, -1, 454, -1, 455, + -1, 456, -1, 458, -1, 459, -1, 460, -1, 461, + -1, 462, -1, 465, -1, 467, -1, 469, -1, 470, + -1, 471, -1, 472, -1, 473, -1, 474, -1, 475, + -1, 478, -1, 481, -1, 482, -1, 483, -1, 484, + -1, 485, -1, 486, -1, 498, -1, 499, -1, 500, + -1, 501, -1, 53, -1, 54, -1, 56, -1, 57, + -1, 71, -1, 72, -1, 79, -1, 83, -1, 112, + -1, 115, -1, 152, -1, 159, -1, 165, -1, 176, + -1, 182, -1, 183, -1, 210, -1, 216, -1, 217, + -1, 219, -1, 247, -1, 268, -1, 270, -1, 274, + -1, 281, -1, 283, -1, 299, -1, 303, -1, 321, + -1, 325, -1, 342, -1, 368, -1, 390, -1, 397, + -1, 412, -1, 414, -1, 429, -1, 430, -1, 435, + -1, 437, -1, 441, -1, 463, -1, 464, -1, 487, + -1, 488, -1, 489, -1, 490, -1, 491, -1, 492, + -1, 493, -1, 494, -1, 495, -1, 496, -1, 497, + -1, 42, -1, 49, -1, 55, -1, 81, -1, 89, + -1, 101, -1, 171, -1, 173, -1, 176, -1, 177, + -1, 194, -1, 209, -1, 222, -1, 223, -1, 225, + -1, 235, -1, 237, -1, 247, -1, 269, -1, 278, + -1, 300, -1, 302, -1, 322, -1, 364, -1, 394, + -1, 412, -1, 421, -1, 468, -1, 37, -1, 42, + -1, 49, -1, 55, -1, 81, -1, 83, -1, 89, + -1, 101, -1, 171, -1, 173, -1, 177, -1, 194, + -1, 209, -1, 222, -1, 223, -1, 225, -1, 235, + -1, 237, -1, 269, -1, 278, -1, 300, -1, 302, + -1, 322, -1, 364, -1, 383, -1, 394, -1, 421, + -1, 441, -1, 468, -1, 37, -1, 42, -1, 49, + -1, 53, -1, 54, -1, 55, -1, 56, -1, 57, + -1, 72, -1, 71, -1, 79, -1, 81, -1, 83, + -1, 89, -1, 101, -1, 112, -1, 115, -1, 152, + -1, 159, -1, 165, -1, 171, -1, 173, -1, 176, + -1, 177, -1, 182, -1, 183, -1, 194, -1, 209, + -1, 210, -1, 217, -1, 219, -1, 216, -1, 222, + -1, 223, -1, 225, -1, 235, -1, 237, -1, 247, + -1, 268, -1, 269, -1, 270, -1, 274, -1, 278, + -1, 281, -1, 283, -1, 300, -1, 299, -1, 302, + -1, 303, -1, 321, -1, 322, -1, 325, -1, 342, + -1, 364, -1, 368, -1, 383, -1, 390, -1, 394, + -1, 397, -1, 412, -1, 414, -1, 421, -1, 429, + -1, 430, -1, 435, -1, 437, -1, 441, -1, 463, + -1, 464, -1, 468, -1, 487, -1, 488, -1, 489, + -1, 490, -1, 491, -1, 492, -1, 493, -1, 494, + -1, 495, -1, 496, -1, 497, -1, 37, -1, 42, + -1, 49, -1, 55, -1, 81, -1, 83, -1, 89, + -1, 101, -1, 171, -1, 173, -1, 176, -1, 177, + -1, 194, -1, 209, -1, 222, -1, 223, -1, 225, + -1, 235, -1, 237, -1, 247, -1, 269, -1, 278, + -1, 300, -1, 302, -1, 322, -1, 364, -1, 383, + -1, 394, -1, 412, -1, 421, -1, 441, -1, 468, + -1, 30, -1, 34, -1, 35, -1, 36, -1, 38, + -1, 39, -1, 40, -1, 41, -1, 45, -1, 58, + -1, 65, -1, 66, -1, 74, -1, 80, -1, 82, + -1, 93, -1, 100, -1, 117, -1, 119, -1, 126, + -1, 127, -1, 132, -1, 133, -1, 139, -1, 143, + -1, 147, -1, 160, -1, 162, -1, 167, -1, 169, + -1, 172, -1, 179, -1, 181, -1, 186, -1, 199, + -1, 207, -1, 218, -1, 220, -1, 232, -1, 233, + -1, 238, -1, 275, -1, 280, -1, 287, -1, 290, + -1, 291, -1, 295, -1, 296, -1, 315, -1, 316, + -1, 317, -1, 318, -1, 329, -1, 336, -1, 347, + -1, 361, -1, 382, -1, 393, -1, 399, -1, 415, + -1, 416, -1, 419, -1, 427, -1, 431, -1, 432, + -1, 438, -1, 447, -1, 448, -1, 452, -1, 457, + -1, 466, -1, 476, -1, 477, -1, 479, -1, 480, + -1 }; /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ @@ -2717,34 +2718,34 @@ static const yytype_uint16 yyrline[] = 2704, 2708, 2722, 2723, 2737, 2738, 2739, 2750, 2774, 2785, 2795, 2799, 2803, 2810, 2814, 2821, 2828, 2829, 2830, 2831, 2832, 2833, 2834, 2835, 2846, 2851, 2860, 2866, 2873, 2893, - 2897, 2903, 2910, 2918, 2926, 2937, 2957, 2993, 3004, 3005, - 3012, 3018, 3020, 3022, 3026, 3035, 3040, 3047, 3062, 3069, - 3073, 3077, 3081, 3085, 3095, 3103, 3112, 3134, 3135, 3139, - 3140, 3141, 3145, 3146, 3153, 3154, 3158, 3159, 3164, 3172, - 3174, 3188, 3191, 3218, 3219, 3222, 3223, 3231, 3239, 3247, - 3256, 3266, 3284, 3330, 3339, 3348, 3357, 3366, 3378, 3379, - 3380, 3381, 3382, 3396, 3397, 3400, 3401, 3405, 3415, 3416, - 3420, 3421, 3425, 3432, 3433, 3438, 3439, 3444, 3445, 3448, - 3449, 3450, 3453, 3454, 3457, 3458, 3459, 3460, 3461, 3462, - 3463, 3464, 3465, 3466, 3467, 3468, 3469, 3470, 3473, 3475, - 3480, 3482, 3487, 3489, 3491, 3493, 3495, 3497, 3499, 3501, - 3515, 3517, 3522, 3526, 3533, 3538, 3544, 3548, 3555, 3560, - 3567, 3572, 3580, 3584, 3590, 3594, 3603, 3614, 3615, 3619, - 3623, 3630, 3631, 3632, 3633, 3634, 3635, 3636, 3637, 3638, - 3639, 3640, 3641, 3642, 3643, 3644, 3654, 3658, 3665, 3672, - 3673, 3689, 3693, 3698, 3702, 3717, 3722, 3726, 3729, 3732, - 3733, 3734, 3737, 3744, 3745, 3746, 3756, 3770, 3771, 3775, - 3786, 3787, 3790, 3791, 3795, 3796, 3799, 3805, 3809, 3816, - 3824, 3832, 3840, 3850, 3851, 3856, 3857, 3861, 3862, 3863, - 3867, 3876, 3884, 3892, 3901, 3916, 3917, 3922, 3923, 3933, - 3934, 3938, 3939, 3943, 3944, 3947, 3963, 3971, 3979, 3989, - 3990, 3994, 3998, 4004, 4006, 4011, 4012, 4016, 4017, 4020, - 4024, 4025, 4029, 4030, 4033, 4034, 4035, 4038, 4042, 4043, - 4047, 4048, 4050, 4051, 4052, 4062, 4063, 4067, 4069, 4075, - 4076, 4080, 4081, 4084, 4095, 4098, 4109, 4113, 4117, 4129, - 4133, 4142, 4149, 4187, 4191, 4195, 4199, 4203, 4207, 4211, - 4217, 4234, 4235, 4236, 4239, 4240, 4241, 4244, 4245, 4246, - 4249, 4250, 4253, 4255, 4260, 4261, 4264, 4268, 4269, 7, + 2897, 2904, 2911, 2919, 2927, 2938, 2958, 2994, 3005, 3006, + 3013, 3019, 3021, 3023, 3027, 3036, 3041, 3048, 3063, 3070, + 3074, 3078, 3082, 3086, 3096, 3104, 3113, 3135, 3136, 3140, + 3141, 3142, 3146, 3147, 3154, 3155, 3159, 3160, 3165, 3173, + 3175, 3189, 3192, 3219, 3220, 3223, 3224, 3232, 3240, 3248, + 3257, 3267, 3285, 3331, 3340, 3349, 3358, 3367, 3379, 3380, + 3381, 3382, 3383, 3397, 3398, 3401, 3402, 3406, 3416, 3417, + 3421, 3422, 3426, 3433, 3434, 3439, 3440, 3445, 3446, 3449, + 3450, 3451, 3454, 3455, 3458, 3459, 3460, 3461, 3462, 3463, + 3464, 3465, 3466, 3467, 3468, 3469, 3470, 3471, 3474, 3476, + 3481, 3483, 3488, 3490, 3492, 3494, 3496, 3498, 3500, 3502, + 3516, 3518, 3523, 3527, 3534, 3539, 3545, 3549, 3556, 3561, + 3568, 3573, 3581, 3585, 3591, 3595, 3604, 3615, 3616, 3620, + 3624, 3631, 3632, 3633, 3634, 3635, 3636, 3637, 3638, 3639, + 3640, 3641, 3642, 3643, 3644, 3645, 3655, 3659, 3666, 3673, + 3674, 3690, 3694, 3699, 3703, 3718, 3723, 3727, 3730, 3733, + 3734, 3735, 3738, 3745, 3746, 3747, 3757, 3771, 3772, 3776, + 3787, 3788, 3791, 3792, 3796, 3797, 3800, 3806, 3810, 3817, + 3825, 3833, 3841, 3851, 3852, 3857, 3858, 3862, 3863, 3864, + 3868, 3877, 3885, 3893, 3902, 3917, 3918, 3923, 3924, 3934, + 3935, 3939, 3940, 3944, 3945, 3948, 3964, 3972, 3980, 3990, + 3991, 3995, 3999, 4005, 4007, 4012, 4013, 4017, 4018, 4021, + 4025, 4026, 4030, 4031, 4034, 4035, 4036, 4039, 4043, 4044, + 4048, 4049, 4051, 4052, 4053, 4063, 4064, 4068, 4070, 4076, + 4077, 4081, 4082, 4085, 4096, 4099, 4110, 4114, 4118, 4130, + 4134, 4143, 4150, 4188, 4192, 4196, 4200, 4204, 4208, 4212, + 4218, 4235, 4236, 4237, 4240, 4241, 4242, 4245, 4246, 4247, + 4250, 4251, 4254, 4256, 4261, 4262, 4265, 4269, 4270, 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, @@ -3454,7 +3455,7 @@ static const yytype_uint8 yyr2[] = 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, - 4, 6, 7, 9, 7, 7, 5, 1, 1, 1, + 5, 6, 7, 9, 7, 7, 5, 1, 1, 1, 5, 6, 6, 4, 4, 4, 4, 6, 5, 5, 5, 4, 6, 4, 1, 7, 9, 5, 0, 5, 4, 0, 1, 0, 2, 0, 1, 3, 3, 2, @@ -3704,7 +3705,7 @@ static const yytype_uint16 yydefact[] = 1935, 1885, 1936, 1937, 0, 1938, 1939, 1891, 1941, 1942, 1943, 1944, 1945, 1946, 1947, 1948, 1898, 1950, 1951, 1952, 1953, 1954, 1955, 2096, 1956, 1912, 1958, 1918, 0, 1959, - 1049, 0, 1174, 609, 1172, 1326, 0, 113, 1313, 0, + 1049, 607, 1174, 609, 1172, 1326, 0, 113, 1313, 0, 1378, 0, 0, 0, 0, 497, 0, 0, 0, 0, 1338, 0, 1664, 207, 211, 0, 1664, 202, 1664, 371, 0, 1664, 371, 1664, 0, 1352, 1355, 0, 436, 431, @@ -3757,662 +3758,662 @@ static const yytype_uint16 yydefact[] = 248, 0, 239, 240, 237, 241, 242, 0, 0, 227, 228, 0, 0, 0, 0, 226, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1509, 1502, 1229, 1234, 609, - 609, 609, 1050, 0, 607, 608, 0, 0, 0, 0, - 0, 484, 369, 379, 0, 0, 0, 1342, 206, 0, - 0, 0, 0, 0, 0, 406, 1345, 1343, 1341, 1344, - 1346, 1634, 190, 0, 0, 0, 0, 0, 198, 201, - 0, 368, 342, 0, 0, 1357, 0, 0, 457, 455, - 458, 447, 460, 450, 0, 1664, 358, 1354, 0, 1506, - 0, 0, 253, 443, 1322, 0, 440, 443, 1288, 0, - 443, 221, 0, 0, 1390, 1433, 231, 251, 232, 252, - 499, 494, 524, 0, 502, 507, 482, 0, 482, 0, - 504, 508, 482, 503, 0, 482, 498, 0, 1073, 0, - 1063, 0, 0, 786, 0, 0, 1064, 999, 1000, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1017, 1016, 1065, - 790, 0, 793, 0, 0, 1203, 1204, 0, 1066, 0, - 0, 1210, 0, 0, 0, 1071, 0, 728, 0, 0, - 634, 635, 643, 639, 646, 0, 649, 636, 585, 541, - 1655, 1695, 0, 596, 596, 596, 594, 584, 0, 671, - 729, 0, 0, 0, 752, 0, 0, 754, 756, 0, - 0, 759, 0, 735, 734, 0, 0, 0, 0, 798, - 0, 1293, 0, 0, 197, 0, 0, 0, 823, 0, - 0, 0, 813, 809, 0, 905, 906, 907, 908, 909, - 910, 911, 912, 913, 914, 915, 916, 917, 829, 1330, - 0, 835, 1333, 0, 1334, 1335, 1332, 1329, 1336, 1337, - 0, 0, 0, 0, 1221, 1217, 0, 0, 0, 0, - 1123, 1125, 1127, 0, 867, 866, 1132, 1138, 1141, 1145, - 1146, 1147, 1142, 1143, 1144, 1134, 1135, 1136, 1137, 1139, - 1140, 0, 1160, 0, 1114, 0, 0, 0, 0, 0, - 0, 0, 1261, 1260, 0, 1284, 0, 1046, 1030, 0, - 0, 1121, 1047, 1268, 1258, 1236, 0, 0, 0, 1306, - 1305, 927, 936, 939, 971, 972, 943, 944, 945, 949, - 1328, 1327, 1255, 0, 1247, 0, 0, 928, 953, 958, - 0, 1212, 1215, 988, 1214, 0, 976, 0, 966, 0, - 974, 978, 954, 969, 0, 950, 0, 1248, 1157, 1159, - 0, 1155, 0, 940, 941, 942, 932, 933, 934, 935, - 937, 938, 946, 1131, 1129, 1130, 0, 1234, 0, 1246, - 0, 0, 1083, 0, 0, 973, 1252, 0, 797, 609, - 797, 0, 925, 1495, 1325, 1488, 1325, 1477, 1167, 1290, - 1324, 581, 0, 0, 0, 1497, 147, 151, 0, 1235, - 181, 183, 712, 0, 616, 617, 621, 0, 0, 621, - 600, 549, 1909, 1790, 0, 0, 0, 0, 660, 701, - 0, 692, 657, 658, 0, 656, 1297, 661, 1296, 662, - 665, 666, 633, 1285, 702, 704, 0, 697, 0, 1291, - 555, 574, 0, 0, 0, 0, 0, 538, 537, 708, - 1472, 1472, 1474, 1473, 0, 50, 0, 1664, 67, 0, - 0, 0, 0, 0, 0, 273, 0, 373, 273, 105, - 1664, 443, 1664, 443, 1558, 1629, 1808, 0, 63, 347, - 96, 0, 133, 376, 0, 332, 86, 101, 126, 0, - 0, 52, 224, 238, 243, 129, 247, 244, 1362, 245, - 140, 0, 48, 0, 127, 0, 1360, 0, 0, 54, - 131, 1364, 1510, 0, 1233, 0, 607, 607, 607, 0, - 1173, 0, 0, 0, 1175, 1176, 966, 1372, 1371, 1373, - 1370, 470, 483, 0, 370, 0, 496, 473, 474, 484, - 1340, 211, 0, 202, 371, 0, 371, 0, 1342, 0, - 0, 192, 188, 206, 212, 0, 0, 0, 0, 0, - 369, 361, 359, 392, 0, 366, 360, 0, 0, 318, - 0, 1552, 0, 0, 0, 0, 464, 0, 0, 0, - 0, 0, 0, 255, 256, 409, 1323, 411, 0, 413, - 220, 218, 1385, 2026, 490, 1171, 0, 488, 495, 489, - 492, 493, 487, 486, 0, 481, 0, 517, 0, 0, - 0, 0, 0, 0, 0, 0, 1060, 1179, 0, 1198, - 1197, 998, 1005, 1008, 1012, 1013, 1014, 1199, 0, 0, - 0, 1009, 1010, 1011, 1001, 1002, 1003, 1004, 1006, 1007, - 1015, 795, 0, 0, 789, 1208, 1207, 1201, 1202, 0, - 1068, 1069, 1070, 1209, 0, 0, 764, 638, 640, 637, - 0, 0, 797, 596, 596, 596, 596, 593, 0, 0, - 0, 796, 0, 688, 760, 758, 0, 782, 0, 755, - 0, 761, 0, 746, 0, 753, 802, 769, 0, 0, - 771, 1463, 819, 0, 814, 810, 0, 0, 0, 820, - 0, 0, 0, 0, 0, 0, 0, 1178, 0, 602, - 1044, 0, 0, 0, 1218, 0, 994, 836, 849, 0, - 1126, 1048, 0, 1149, 1113, 877, 876, 878, 878, 0, - 1263, 1265, 0, 0, 0, 0, 1275, 0, 995, 1226, - 0, 1074, 1224, 1167, 1117, 1119, 1276, 1029, 861, 925, - 0, 0, 0, 0, 0, 0, 0, 977, 968, 0, - 975, 979, 0, 0, 0, 962, 0, 0, 960, 989, - 956, 0, 0, 990, 1233, 0, 1237, 0, 0, 1082, - 1091, 715, 711, 671, 607, 671, 0, 1457, 1479, 1476, - 582, 156, 1498, 0, 170, 0, 0, 0, 0, 173, - 187, 184, 1497, 0, 0, 611, 613, 0, 1150, 621, - 615, 664, 663, 0, 631, 699, 629, 0, 705, 0, - 572, 0, 558, 0, 738, 0, 0, 1466, 1467, 0, - 0, 0, 322, 0, 0, 0, 273, 0, 381, 0, - 388, 0, 0, 373, 354, 85, 0, 0, 0, 59, - 104, 77, 69, 55, 83, 0, 0, 88, 0, 81, - 98, 99, 97, 102, 0, 283, 308, 0, 0, 319, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 499, 1234, 1230, 1234, 0, 0, 0, 609, 605, - 606, 1051, 0, 469, 523, 520, 521, 519, 229, 380, - 0, 0, 0, 200, 368, 0, 1357, 449, 452, 1339, - 406, 0, 193, 0, 191, 211, 0, 0, 202, 371, - 0, 346, 342, 367, 340, 339, 341, 0, 1553, 222, - 0, 1547, 371, 1356, 0, 0, 465, 456, 0, 461, - 0, 0, 459, 0, 1351, 254, 443, 0, 477, 518, - 525, 505, 510, 0, 516, 512, 511, 506, 514, 513, - 509, 1061, 1072, 1196, 0, 0, 0, 0, 788, 791, - 0, 1067, 1062, 762, 0, 0, 671, 0, 0, 0, - 0, 587, 586, 592, 0, 0, 1085, 757, 0, 0, - 0, 744, 733, 739, 740, 0, 0, 0, 800, 799, - 770, 823, 0, 803, 823, 0, 823, 0, 821, 0, - 830, 918, 919, 920, 921, 922, 923, 924, 855, 0, - 1220, 1216, 1122, 1124, 1161, 873, 871, 993, 1266, 1259, - 1262, 1166, 1270, 1272, 0, 0, 0, 0, 1283, 0, - 0, 1116, 1284, 1304, 929, 0, 0, 959, 1213, 980, - 0, 0, 0, 955, 1149, 0, 0, 0, 0, 0, - 964, 0, 1241, 1234, 0, 1240, 0, 0, 0, 0, - 1056, 716, 688, 0, 688, 0, 0, 1496, 0, 1491, - 148, 149, 150, 0, 0, 0, 165, 142, 0, 0, - 182, 170, 158, 619, 620, 0, 614, 630, 1286, 1292, - 557, 0, 1026, 0, 0, 554, 0, 134, 273, 0, - 0, 66, 0, 390, 334, 382, 365, 349, 0, 0, - 0, 274, 0, 407, 0, 0, 355, 0, 0, 0, - 0, 335, 0, 0, 294, 0, 0, 365, 0, 372, - 290, 291, 0, 58, 78, 0, 74, 0, 103, 0, - 0, 0, 0, 0, 61, 73, 0, 56, 808, 443, - 443, 64, 1317, 1960, 1961, 1962, 1963, 1964, 1965, 1966, - 1967, 1968, 1969, 2080, 1970, 1971, 1972, 1973, 1974, 1975, - 1976, 1977, 2089, 1978, 280, 1979, 1733, 1980, 1981, 1982, - 1983, 1984, 0, 1985, 806, 1986, 1987, 2168, 1988, 1134, - 1135, 279, 278, 375, 275, 383, 277, 0, 1318, 276, - 378, 333, 130, 1363, 0, 128, 0, 1361, 137, 135, - 132, 1365, 1503, 0, 0, 1054, 1055, 1052, 607, 0, - 0, 0, 499, 476, 0, 0, 0, 1552, 0, 0, - 1664, 0, 189, 0, 0, 203, 1357, 199, 368, 0, - 398, 318, 393, 0, 1552, 1550, 0, 1357, 1546, 448, - 451, 0, 0, 540, 453, 0, 0, 0, 414, 491, - 0, 515, 1018, 0, 0, 0, 0, 647, 0, 653, - 688, 591, 590, 589, 588, 670, 1603, 1892, 1789, 0, - 674, 669, 672, 677, 679, 678, 680, 676, 687, 0, - 690, 781, 1162, 1164, 0, 0, 0, 0, 745, 747, - 0, 749, 0, 801, 817, 0, 818, 0, 816, 811, - 822, 1219, 1264, 1273, 1274, 1269, 1278, 1280, 0, 0, - 0, 926, 1225, 996, 986, 984, 981, 0, 982, 963, - 0, 0, 961, 957, 0, 991, 0, 0, 1238, 0, - 1077, 0, 1080, 1094, 1090, 1089, 1085, 1051, 1085, 1458, - 580, 169, 146, 172, 171, 0, 1235, 179, 0, 0, - 170, 0, 174, 466, 0, 0, 569, 737, 562, 563, - 0, 386, 68, 0, 365, 0, 273, 351, 350, 353, - 348, 352, 0, 408, 0, 0, 292, 0, 299, 337, - 338, 336, 293, 365, 371, 295, 0, 0, 0, 70, - 60, 57, 62, 71, 0, 0, 72, 75, 802, 807, - 87, 80, 1317, 2089, 2098, 0, 0, 0, 0, 0, - 1232, 1231, 0, 472, 471, 522, 468, 479, 229, 0, - 0, 0, 342, 1549, 0, 0, 0, 368, 194, 0, - 0, 0, 0, 1552, 0, 0, 270, 0, 315, 0, - 215, 1551, 0, 0, 1538, 0, 0, 1349, 1350, 0, - 478, 1019, 0, 1020, 792, 0, 0, 645, 1085, 0, - 0, 0, 681, 675, 0, 1084, 1086, 0, 642, 1165, - 741, 0, 743, 0, 767, 0, 767, 750, 812, 804, - 1271, 1281, 1282, 1277, 1075, 0, 983, 987, 985, 965, - 1234, 1242, 1234, 1239, 1079, 1093, 1096, 690, 1302, 690, - 0, 0, 157, 0, 0, 154, 141, 159, 1151, 559, - 560, 0, 273, 0, 364, 387, 304, 282, 0, 0, - 0, 289, 296, 397, 298, 0, 79, 95, 0, 0, - 377, 138, 136, 1053, 499, 0, 205, 1357, 318, 1546, - 0, 0, 0, 0, 342, 222, 1548, 331, 324, 325, - 326, 327, 328, 329, 330, 345, 344, 316, 317, 0, - 0, 0, 0, 454, 1351, 0, 176, 185, 0, 176, - 1021, 648, 0, 690, 0, 0, 0, 673, 0, 0, - 689, 0, 545, 1163, 0, 732, 730, 0, 731, 1279, - 0, 0, 0, 0, 609, 642, 642, 143, 0, 144, - 180, 0, 0, 0, 371, 389, 363, 0, 356, 302, - 301, 303, 307, 0, 305, 0, 321, 0, 314, 282, - 0, 82, 0, 384, 467, 475, 0, 272, 1540, 368, - 0, 204, 1546, 318, 1552, 1546, 0, 1543, 0, 0, - 0, 0, 178, 1357, 0, 178, 0, 642, 683, 0, - 682, 1088, 1087, 644, 742, 0, 1076, 1244, 1243, 0, - 1100, 544, 543, 0, 0, 0, 0, 397, 0, 343, - 0, 0, 304, 0, 297, 394, 395, 396, 0, 310, - 300, 311, 76, 94, 385, 0, 368, 1541, 271, 216, - 1539, 1544, 1545, 0, 176, 175, 618, 177, 797, 186, - 618, 652, 546, 684, 641, 748, 1095, 0, 0, 0, - 0, 0, 153, 797, 164, 0, 314, 362, 357, 281, - 306, 320, 0, 0, 0, 312, 0, 313, 1546, 0, - 178, 621, 1347, 621, 1878, 1604, 1843, 0, 1112, 1101, - 1112, 1112, 1092, 145, 152, 0, 273, 286, 0, 285, - 0, 374, 309, 1542, 1357, 618, 166, 167, 0, 1105, - 1104, 1103, 1107, 1106, 0, 1099, 1097, 1098, 797, 391, - 284, 288, 287, 797, 621, 0, 0, 1109, 0, 1110, - 163, 1348, 168, 1102, 1108, 1111 + 609, 609, 0, 0, 0, 0, 607, 608, 0, 0, + 0, 0, 0, 484, 369, 379, 0, 0, 0, 1342, + 206, 0, 0, 0, 0, 0, 0, 406, 1345, 1343, + 1341, 1344, 1346, 1634, 190, 0, 0, 0, 0, 0, + 198, 201, 0, 368, 342, 0, 0, 1357, 0, 0, + 457, 455, 458, 447, 460, 450, 0, 1664, 358, 1354, + 0, 1506, 0, 0, 253, 443, 1322, 0, 440, 443, + 1288, 0, 443, 221, 0, 0, 1390, 1433, 231, 251, + 232, 252, 499, 494, 524, 0, 502, 507, 482, 0, + 482, 0, 504, 508, 482, 503, 0, 482, 498, 0, + 1073, 0, 1063, 0, 0, 786, 0, 0, 1064, 999, + 1000, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1017, + 1016, 1065, 790, 0, 793, 0, 0, 1203, 1204, 0, + 1066, 0, 0, 1210, 0, 0, 0, 1071, 0, 728, + 0, 0, 634, 635, 643, 639, 646, 0, 649, 636, + 585, 541, 1655, 1695, 0, 596, 596, 596, 594, 584, + 0, 671, 729, 0, 0, 0, 752, 0, 0, 754, + 756, 0, 0, 759, 0, 735, 734, 0, 0, 0, + 0, 798, 0, 1293, 0, 0, 197, 0, 0, 0, + 823, 0, 0, 0, 813, 809, 0, 905, 906, 907, + 908, 909, 910, 911, 912, 913, 914, 915, 916, 917, + 829, 1330, 0, 835, 1333, 0, 1334, 1335, 1332, 1329, + 1336, 1337, 0, 0, 0, 0, 1221, 1217, 0, 0, + 0, 0, 1123, 1125, 1127, 0, 867, 866, 1132, 1138, + 1141, 1145, 1146, 1147, 1142, 1143, 1144, 1134, 1135, 1136, + 1137, 1139, 1140, 0, 1160, 0, 1114, 0, 0, 0, + 0, 0, 0, 0, 1261, 1260, 0, 1284, 0, 1046, + 1030, 0, 0, 1121, 1047, 1268, 1258, 1236, 0, 0, + 0, 1306, 1305, 927, 936, 939, 971, 972, 943, 944, + 945, 949, 1328, 1327, 1255, 0, 1247, 0, 0, 928, + 953, 958, 0, 1212, 1215, 988, 1214, 0, 976, 0, + 966, 0, 974, 978, 954, 969, 0, 950, 0, 1248, + 1157, 1159, 0, 1155, 0, 940, 941, 942, 932, 933, + 934, 935, 937, 938, 946, 1131, 1129, 1130, 0, 1234, + 0, 1246, 0, 0, 1083, 0, 0, 973, 1252, 0, + 797, 609, 797, 0, 925, 1495, 1325, 1488, 1325, 1477, + 1167, 1290, 1324, 581, 0, 0, 0, 1497, 147, 151, + 0, 1235, 181, 183, 712, 0, 616, 617, 621, 0, + 0, 621, 600, 549, 1909, 1790, 0, 0, 0, 0, + 660, 701, 0, 692, 657, 658, 0, 656, 1297, 661, + 1296, 662, 665, 666, 633, 1285, 702, 704, 0, 697, + 0, 1291, 555, 574, 0, 0, 0, 0, 0, 538, + 537, 708, 1472, 1472, 1474, 1473, 0, 50, 0, 1664, + 67, 0, 0, 0, 0, 0, 0, 273, 0, 373, + 273, 105, 1664, 443, 1664, 443, 1558, 1629, 1808, 0, + 63, 347, 96, 0, 133, 376, 0, 332, 86, 101, + 126, 0, 0, 52, 224, 238, 243, 129, 247, 244, + 1362, 245, 140, 0, 48, 0, 127, 0, 1360, 0, + 0, 54, 131, 1364, 1510, 0, 1233, 0, 607, 607, + 607, 605, 606, 1050, 0, 1173, 0, 1175, 1176, 966, + 1372, 1371, 1373, 1370, 470, 483, 0, 370, 0, 496, + 473, 474, 484, 1340, 211, 0, 202, 371, 0, 371, + 0, 1342, 0, 0, 192, 188, 206, 212, 0, 0, + 0, 0, 0, 369, 361, 359, 392, 0, 366, 360, + 0, 0, 318, 0, 1552, 0, 0, 0, 0, 464, + 0, 0, 0, 0, 0, 0, 255, 256, 409, 1323, + 411, 0, 413, 220, 218, 1385, 2026, 490, 1171, 0, + 488, 495, 489, 492, 493, 487, 486, 0, 481, 0, + 517, 0, 0, 0, 0, 0, 0, 0, 0, 1060, + 1179, 0, 1198, 1197, 998, 1005, 1008, 1012, 1013, 1014, + 1199, 0, 0, 0, 1009, 1010, 1011, 1001, 1002, 1003, + 1004, 1006, 1007, 1015, 795, 0, 0, 789, 1208, 1207, + 1201, 1202, 0, 1068, 1069, 1070, 1209, 0, 0, 764, + 638, 640, 637, 0, 0, 797, 596, 596, 596, 596, + 593, 0, 0, 0, 796, 0, 688, 760, 758, 0, + 782, 0, 755, 0, 761, 0, 746, 0, 753, 802, + 769, 0, 0, 771, 1463, 819, 0, 814, 810, 0, + 0, 0, 820, 0, 0, 0, 0, 0, 0, 0, + 1178, 0, 602, 1044, 0, 0, 0, 1218, 0, 994, + 836, 849, 0, 1126, 1048, 0, 1149, 1113, 877, 876, + 878, 878, 0, 1263, 1265, 0, 0, 0, 0, 1275, + 0, 995, 1226, 0, 1074, 1224, 1167, 1117, 1119, 1276, + 1029, 861, 925, 0, 0, 0, 0, 0, 0, 0, + 977, 968, 0, 975, 979, 0, 0, 0, 962, 0, + 0, 960, 989, 956, 0, 0, 990, 1233, 0, 1237, + 0, 0, 1082, 1091, 715, 711, 671, 607, 671, 0, + 1457, 1479, 1476, 582, 156, 1498, 0, 170, 0, 0, + 0, 0, 173, 187, 184, 1497, 0, 0, 611, 613, + 0, 1150, 621, 615, 664, 663, 0, 631, 699, 629, + 0, 705, 0, 572, 0, 558, 0, 738, 0, 0, + 1466, 1467, 0, 0, 0, 322, 0, 0, 0, 273, + 0, 381, 0, 388, 0, 0, 373, 354, 85, 0, + 0, 0, 59, 104, 77, 69, 55, 83, 0, 0, + 88, 0, 81, 98, 99, 97, 102, 0, 283, 308, + 0, 0, 319, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 499, 1234, 1230, 1234, 0, 0, + 0, 609, 1051, 0, 469, 523, 520, 521, 519, 229, + 380, 0, 0, 0, 200, 368, 0, 1357, 449, 452, + 1339, 406, 0, 193, 0, 191, 211, 0, 0, 202, + 371, 0, 346, 342, 367, 340, 339, 341, 0, 1553, + 222, 0, 1547, 371, 1356, 0, 0, 465, 456, 0, + 461, 0, 0, 459, 0, 1351, 254, 443, 0, 477, + 518, 525, 505, 510, 0, 516, 512, 511, 506, 514, + 513, 509, 1061, 1072, 1196, 0, 0, 0, 0, 788, + 791, 0, 1067, 1062, 762, 0, 0, 671, 0, 0, + 0, 0, 587, 586, 592, 0, 0, 1085, 757, 0, + 0, 0, 744, 733, 739, 740, 0, 0, 0, 800, + 799, 770, 823, 0, 803, 823, 0, 823, 0, 821, + 0, 830, 918, 919, 920, 921, 922, 923, 924, 855, + 0, 1220, 1216, 1122, 1124, 1161, 873, 871, 993, 1266, + 1259, 1262, 1166, 1270, 1272, 0, 0, 0, 0, 1283, + 0, 0, 1116, 1284, 1304, 929, 0, 0, 959, 1213, + 980, 0, 0, 0, 955, 1149, 0, 0, 0, 0, + 0, 964, 0, 1241, 1234, 0, 1240, 0, 0, 0, + 0, 1056, 716, 688, 0, 688, 0, 0, 1496, 0, + 1491, 148, 149, 150, 0, 0, 0, 165, 142, 0, + 0, 182, 170, 158, 619, 620, 0, 614, 630, 1286, + 1292, 557, 0, 1026, 0, 0, 554, 0, 134, 273, + 0, 0, 66, 0, 390, 334, 382, 365, 349, 0, + 0, 0, 274, 0, 407, 0, 0, 355, 0, 0, + 0, 0, 335, 0, 0, 294, 0, 0, 365, 0, + 372, 290, 291, 0, 58, 78, 0, 74, 0, 103, + 0, 0, 0, 0, 0, 61, 73, 0, 56, 808, + 443, 443, 64, 1317, 1960, 1961, 1962, 1963, 1964, 1965, + 1966, 1967, 1968, 1969, 2080, 1970, 1971, 1972, 1973, 1974, + 1975, 1976, 1977, 2089, 1978, 280, 1979, 1733, 1980, 1981, + 1982, 1983, 1984, 0, 1985, 806, 1986, 1987, 2168, 1988, + 1134, 1135, 279, 278, 375, 275, 383, 277, 0, 1318, + 276, 378, 333, 130, 1363, 0, 128, 0, 1361, 137, + 135, 132, 1365, 1503, 0, 0, 1054, 1055, 1052, 607, + 0, 0, 0, 499, 476, 0, 0, 0, 1552, 0, + 0, 1664, 0, 189, 0, 0, 203, 1357, 199, 368, + 0, 398, 318, 393, 0, 1552, 1550, 0, 1357, 1546, + 448, 451, 0, 0, 540, 453, 0, 0, 0, 414, + 491, 0, 515, 1018, 0, 0, 0, 0, 647, 0, + 653, 688, 591, 590, 589, 588, 670, 1603, 1892, 1789, + 0, 674, 669, 672, 677, 679, 678, 680, 676, 687, + 0, 690, 781, 1162, 1164, 0, 0, 0, 0, 745, + 747, 0, 749, 0, 801, 817, 0, 818, 0, 816, + 811, 822, 1219, 1264, 1273, 1274, 1269, 1278, 1280, 0, + 0, 0, 926, 1225, 996, 986, 984, 981, 0, 982, + 963, 0, 0, 961, 957, 0, 991, 0, 0, 1238, + 0, 1077, 0, 1080, 1094, 1090, 1089, 1085, 1051, 1085, + 1458, 580, 169, 146, 172, 171, 0, 1235, 179, 0, + 0, 170, 0, 174, 466, 0, 0, 569, 737, 562, + 563, 0, 386, 68, 0, 365, 0, 273, 351, 350, + 353, 348, 352, 0, 408, 0, 0, 292, 0, 299, + 337, 338, 336, 293, 365, 371, 295, 0, 0, 0, + 70, 60, 57, 62, 71, 0, 0, 72, 75, 802, + 807, 87, 80, 1317, 2089, 2098, 0, 0, 0, 0, + 0, 1232, 1231, 0, 472, 471, 522, 468, 479, 229, + 0, 0, 0, 342, 1549, 0, 0, 0, 368, 194, + 0, 0, 0, 0, 1552, 0, 0, 270, 0, 315, + 0, 215, 1551, 0, 0, 1538, 0, 0, 1349, 1350, + 0, 478, 1019, 0, 1020, 792, 0, 0, 645, 1085, + 0, 0, 0, 681, 675, 0, 1084, 1086, 0, 642, + 1165, 741, 0, 743, 0, 767, 0, 767, 750, 812, + 804, 1271, 1281, 1282, 1277, 1075, 0, 983, 987, 985, + 965, 1234, 1242, 1234, 1239, 1079, 1093, 1096, 690, 1302, + 690, 0, 0, 157, 0, 0, 154, 141, 159, 1151, + 559, 560, 0, 273, 0, 364, 387, 304, 282, 0, + 0, 0, 289, 296, 397, 298, 0, 79, 95, 0, + 0, 377, 138, 136, 1053, 499, 0, 205, 1357, 318, + 1546, 0, 0, 0, 0, 342, 222, 1548, 331, 324, + 325, 326, 327, 328, 329, 330, 345, 344, 316, 317, + 0, 0, 0, 0, 454, 1351, 0, 176, 185, 0, + 176, 1021, 648, 0, 690, 0, 0, 0, 673, 0, + 0, 689, 0, 545, 1163, 0, 732, 730, 0, 731, + 1279, 0, 0, 0, 0, 609, 642, 642, 143, 0, + 144, 180, 0, 0, 0, 371, 389, 363, 0, 356, + 302, 301, 303, 307, 0, 305, 0, 321, 0, 314, + 282, 0, 82, 0, 384, 467, 475, 0, 272, 1540, + 368, 0, 204, 1546, 318, 1552, 1546, 0, 1543, 0, + 0, 0, 0, 178, 1357, 0, 178, 0, 642, 683, + 0, 682, 1088, 1087, 644, 742, 0, 1076, 1244, 1243, + 0, 1100, 544, 543, 0, 0, 0, 0, 397, 0, + 343, 0, 0, 304, 0, 297, 394, 395, 396, 0, + 310, 300, 311, 76, 94, 385, 0, 368, 1541, 271, + 216, 1539, 1544, 1545, 0, 176, 175, 618, 177, 797, + 186, 618, 652, 546, 684, 641, 748, 1095, 0, 0, + 0, 0, 0, 153, 797, 164, 0, 314, 362, 357, + 281, 306, 320, 0, 0, 0, 312, 0, 313, 1546, + 0, 178, 621, 1347, 621, 1878, 1604, 1843, 0, 1112, + 1101, 1112, 1112, 1092, 145, 152, 0, 273, 286, 0, + 285, 0, 374, 309, 1542, 1357, 618, 166, 167, 0, + 1105, 1104, 1103, 1107, 1106, 0, 1099, 1097, 1098, 797, + 391, 284, 288, 287, 797, 621, 0, 0, 1109, 0, + 1110, 163, 1348, 168, 1102, 1108, 1111 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int16 yydefgoto[] = { - -1, 47, 48, 49, 755, 2661, 2662, 2663, 2287, 1225, - 3451, 2288, 1226, 1227, 2665, 756, 806, 1169, 855, 1107, - 1629, 915, 1261, 1262, 757, 1783, 758, 2896, 2207, 2607, - 3433, 54, 3177, 2210, 1183, 3180, 3397, 2889, 3175, 2608, - 3472, 3526, 3178, 2211, 2212, 3398, 2213, 759, 2723, 2724, - 760, 761, 1868, 58, 1324, 551, 1865, 762, 763, 1357, - 1358, 970, 764, 1869, 1811, 3012, 1245, 1801, 1372, 62, - 1892, 765, 107, 911, 64, 766, 2650, 3013, 3444, 2676, - 3581, 2949, 2950, 3441, 3442, 2653, 2290, 3509, 3510, 2738, - 1792, 3504, 2371, 3385, 2294, 2275, 2951, 2379, 3344, 3060, - 2291, 2931, 2372, 3437, 1887, 2373, 3438, 3196, 2374, 1843, - 1872, 2654, 3511, 2295, 1844, 2649, 3014, 1780, 2375, 3448, - 2376, 552, 2935, 767, 746, 747, 962, 1351, 748, 768, - 1878, 1879, 1880, 1881, 1882, 1883, 946, 1884, 769, 770, - 2703, 2349, 3248, 2757, 3249, 2416, 2343, 1381, 2408, 1912, - 1846, 1382, 540, 1926, 2758, 2708, 1913, 771, 1108, 72, - 73, 1017, 74, 3190, 75, 76, 1754, 1755, 1756, 857, - 867, 868, 2203, 1467, 1997, 860, 1188, 1723, 841, 842, - 2333, 883, 1835, 1718, 1719, 2216, 2615, 1747, 1748, 1197, - 1198, 1983, 1984, 3412, 1985, 1986, 1460, 1461, 3287, 1735, - 1739, 1740, 2237, 2227, 1726, 2483, 3100, 3101, 3102, 3103, - 3104, 3105, 3106, 1109, 2796, 3298, 1743, 1744, 1200, 1201, - 1202, 1752, 2247, 78, 79, 2188, 2591, 2592, 812, 813, - 3117, 1490, 1757, 2800, 2801, 2802, 3120, 3121, 3122, 814, - 1012, 1013, 1040, 1035, 1479, 2007, 815, 816, 1960, 1961, - 2454, 1042, 1999, 2018, 2019, 2808, 2507, 1556, 2276, 1557, - 1558, 2033, 1559, 1110, 1560, 1588, 1111, 1593, 1562, 1112, + -1, 47, 48, 49, 755, 2664, 2665, 2666, 2289, 1225, + 3452, 2290, 1226, 1227, 2668, 756, 806, 1169, 855, 1107, + 1629, 915, 1261, 1262, 757, 1783, 758, 2897, 2209, 2610, + 3434, 54, 3178, 2212, 1183, 3181, 3398, 2890, 3176, 2611, + 3473, 3527, 3179, 2213, 2214, 3399, 2215, 759, 2724, 2725, + 760, 761, 1870, 58, 1324, 551, 1867, 762, 763, 1357, + 1358, 970, 764, 1871, 1811, 3013, 1245, 1801, 1372, 62, + 1894, 765, 107, 911, 64, 766, 2653, 3014, 3445, 2679, + 3582, 2950, 2951, 3442, 3443, 2656, 2292, 3510, 3511, 2739, + 1792, 3505, 2374, 3386, 2296, 2277, 2952, 2382, 3345, 3061, + 2293, 2932, 2375, 3438, 1889, 2376, 3439, 3197, 2377, 1845, + 1874, 2657, 3512, 2297, 1846, 2652, 3015, 1780, 2378, 3449, + 2379, 552, 2936, 767, 746, 747, 962, 1351, 748, 768, + 1880, 1881, 1882, 1883, 1884, 1885, 946, 1886, 769, 770, + 2704, 2352, 3249, 2758, 3250, 2419, 2346, 1381, 2411, 1914, + 1848, 1382, 540, 1928, 2759, 2709, 1915, 771, 1108, 72, + 73, 1017, 74, 3191, 75, 76, 1754, 1755, 1756, 857, + 867, 868, 2205, 1467, 1999, 860, 1188, 1723, 841, 842, + 1834, 883, 1837, 1718, 1719, 2218, 2618, 1747, 1748, 1197, + 1198, 1985, 1986, 3413, 1987, 1988, 1460, 1461, 3288, 1735, + 1739, 1740, 2239, 2229, 1726, 2486, 3101, 3102, 3103, 3104, + 3105, 3106, 3107, 1109, 2797, 3299, 1743, 1744, 1200, 1201, + 1202, 1752, 2249, 78, 79, 2190, 2594, 2595, 812, 813, + 3118, 1490, 1757, 2801, 2802, 2803, 3121, 3122, 3123, 814, + 1012, 1013, 1040, 1035, 1479, 2009, 815, 816, 1962, 1963, + 2457, 1042, 2001, 2020, 2021, 2809, 2510, 1556, 2278, 1557, + 1558, 2035, 1559, 1110, 1560, 1588, 1111, 1593, 1562, 1112, 1113, 1114, 1565, 1115, 1116, 1117, 1118, 1581, 1119, 1120, - 1605, 2035, 2036, 2037, 2038, 2039, 2040, 2041, 2042, 2043, - 2044, 2045, 2046, 2047, 2048, 1170, 1758, 1122, 1123, 1124, - 1125, 1126, 1127, 1128, 1129, 1130, 1131, 818, 1132, 2550, - 1133, 1680, 2182, 2590, 3110, 3295, 3296, 2880, 3165, 3326, - 3424, 3540, 3568, 3569, 3595, 1134, 1135, 1624, 1625, 1626, - 2070, 2071, 2072, 2073, 2176, 1674, 1675, 1136, 3016, 1677, - 2093, 3113, 3114, 1171, 1453, 1617, 1303, 1304, 1570, 1427, - 1428, 1434, 1935, 1442, 1446, 1965, 1966, 1454, 2143, 1137, - 2064, 2065, 2525, 1583, 2551, 2552, 1138, 1260, 1630, 2875, - 2179, 1678, 2136, 1145, 1139, 1146, 1141, 1613, 2847, 2541, - 2542, 1614, 2546, 2843, 2844, 2105, 2848, 3137, 3138, 2548, - 2244, 1706, 2249, 2250, 966, 1142, 1143, 1144, 1305, 524, - 1571, 3527, 1347, 1176, 1306, 2132, 772, 1047, 2057, 773, - 1320, 1858, 774, 3278, 3077, 1336, 1888, 2384, 553, 775, - 776, 533, 85, 2338, 927, 86, 87, 88, 892, 1374, - 777, 1375, 1376, 977, 89, 2759, 979, 980, 779, 849, + 1605, 2037, 2038, 2039, 2040, 2041, 2042, 2043, 2044, 2045, + 2046, 2047, 2048, 2049, 2050, 1170, 1758, 1122, 1123, 1124, + 1125, 1126, 1127, 1128, 1129, 1130, 1131, 818, 1132, 2553, + 1133, 1680, 2184, 2593, 3111, 3296, 3297, 2881, 3166, 3327, + 3425, 3541, 3569, 3570, 3596, 1134, 1135, 1624, 1625, 1626, + 2072, 2073, 2074, 2075, 2178, 1674, 1675, 1136, 3017, 1677, + 2095, 3114, 3115, 1171, 1453, 1617, 1303, 1304, 1570, 1427, + 1428, 1434, 1937, 1442, 1446, 1967, 1968, 1454, 2145, 1137, + 2066, 2067, 2528, 1583, 2554, 2555, 1138, 1260, 1630, 2876, + 2181, 1678, 2138, 1145, 1139, 1146, 1141, 1613, 2848, 2544, + 2545, 1614, 2549, 2844, 2845, 2107, 2849, 3138, 3139, 2551, + 2246, 1706, 2251, 2252, 966, 1142, 1143, 1144, 1305, 524, + 1571, 3528, 1347, 1176, 1306, 2134, 772, 1047, 2059, 773, + 1320, 1860, 774, 3279, 3078, 1336, 1890, 2387, 553, 775, + 776, 533, 85, 2341, 927, 86, 87, 88, 892, 1374, + 777, 1375, 1376, 977, 89, 2760, 979, 980, 779, 849, 850, 1499, 1694, 1500, 780, 92, 824, 1767, 781, 1165, - 864, 1166, 1168, 782, 1185, 2604, 2205, 95, 96, 97, + 864, 1166, 1168, 782, 1185, 2607, 2207, 95, 96, 97, 115, 1256, 783, 835, 836, 873, 100, 101, 1213, 837, - 785, 786, 3274, 787, 2741, 1330, 534, 526, 527, 1573, + 785, 786, 3275, 787, 2742, 1330, 534, 526, 527, 1573, 720, 1308, 721 }; /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing STATE-NUM. */ -#define YYPACT_NINF -3080 +#define YYPACT_NINF -3162 static const int yypact[] = { - 6086, -8, 646, -3080, -3080, 298, -8, 51707, 66662, 128, - -8, 129, 2920, 53703, -3080, -3080, 48214, 6090, -8, 56697, - 74058, 330, 436, 32704, 437, 57196, -3080, -3080, -3080, 66662, - 56697, 57695, -8, 363, 67161, -3080, -8, 35700, 54202, 239, - -3080, 56697, 65, 50, 58194, 56697, 4652, 593, 346, -3080, - -3080, -3080, -3080, -3080, 301, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, 168, -3080, 337, 172, 32704, 32704, 97, 371, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, 453, - -3080, -3080, 430, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, 35200, -3080, -3080, -3080, -3080, -3080, -3080, 58693, 56697, - 59192, 54701, 59691, -3080, 654, 953, 633, 196, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - 208, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, 508, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, 209, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, 641, -3080, 553, -3080, 213, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, 1316, -3080, -3080, 946, 1994, - 56697, 379, 742, 757, -3080, 60190, -3080, 737, 56697, -3080, - -3080, 752, 1090, 955, -3080, -3080, 55200, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, 48713, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, 930, -3080, -3080, 759, -3080, 187, -3080, -3080, - 785, 730, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, 834, -3080, -3080, -3080, 870, 67660, 60689, 61188, -3080, - 743, 1581, 7891, 74076, 31704, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, 453, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, 57196, 66662, - 769, 793, 1150, 808, 33702, 819, 36200, 826, 844, 1127, - 857, 879, 897, 920, 50, 32204, 875, 641, 832, 61687, - 61687, 16, 33203, 2103, -3080, 61687, 62186, -3080, 936, -3080, - 953, -3080, -3080, -3080, -3080, -73, 929, -3080, 62685, 62685, - 62685, 959, 1234, 62685, -3080, -3080, -3080, 942, -3080, -3080, - 1174, 20273, 20273, 68159, 68159, 953, 68159, 970, 68159, -3080, - -3080, 43, 633, -3080, 641, -3080, -3080, 97, -3080, -3080, - 54202, -3080, -3080, 333, 1327, 20273, 56697, 978, -3080, 996, - 978, 1002, 1008, 1017, -3080, 6086, 1346, 1256, 55699, 435, - 435, 1508, 435, 948, 1034, 3537, 2504, -3080, 1326, -3080, - 1071, -3080, 56697, 57196, 1173, 1097, 1382, -3080, -3080, 1456, - 1128, 1257, 1471, 2751, 1479, 1322, 1491, 1618, 1493, 1612, - 54, -3080, 20273, 49212, 641, -3080, 11348, 20273, -3080, -3080, - -3080, 1235, -3080, -3080, -3080, -3080, -3080, 56697, 66662, 1137, - 1156, -3080, -3080, -3080, -3080, 1977, 1406, -3080, 1628, 68658, - -3080, -3080, 1213, 63184, 63683, 64182, 64681, 1596, -3080, -3080, - 1541, -3080, -3080, -3080, 1224, -3080, -3080, -3080, 218, 69157, - 1560, 1198, 123, -3080, 1602, 194, -3080, 1604, 1458, 15023, - -3080, 1416, -3080, -3080, -3080, 50, -3080, 727, -3080, -3080, - 45315, -3080, -3080, 74076, 1352, 1267, -3080, 20273, 20273, 1270, - 5728, 61687, 62186, 20273, 56697, -3080, 20273, 24998, 1275, 20273, - 20273, 12398, 20273, 30706, 61687, 2103, 1276, -3080, 584, -3080, - 56697, 1289, -3080, 1389, 1389, 363, 32704, 1617, 32204, 1389, - 1389, 1389, -3080, 1132, 1615, 1549, -3080, 32704, 1549, 1666, - 1335, 1633, 1549, -3080, 257, 1637, 1389, 36699, 1348, -3080, - 1389, 1567, -3080, -3080, 20273, 15023, 71652, 1828, -3080, -3080, - -3080, -3080, 1635, -3080, 66662, 1362, -3080, -3080, -3080, -3080, - -3080, -3080, -79, 1885, 203, 1888, 20273, 203, 203, 1381, - 214, 214, -3080, 1588, 1401, -3080, 215, 1408, 1413, 1934, - 1950, 202, 161, 1072, 203, 20273, -3080, 214, 1443, 1961, - 1450, 1969, 231, 240, -3080, 224, 20273, 20273, 20273, 319, - 20273, 10298, -3080, 49212, 1967, 56697, 784, -3080, 641, 1462, - 953, -3080, -3080, -3080, -3080, -3080, -3080, -3080, 1463, -3080, - 207, 6998, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - 1501, -3080, -3080, -3080, -3080, 1682, 20273, -3080, -3080, 1464, - 1617, -3080, 227, -3080, -3080, 1617, -3080, -3080, -3080, -3080, - -3080, 158, -3080, 1881, 20273, 20273, -3080, 641, 69656, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, 797, -3080, 453, 658, - 47033, 1465, 1470, 978, 56697, 56697, 1952, -3080, -3080, -3080, - -3080, 54202, 131, 1770, 178, 1608, -3080, -3080, 97, 97, - 15548, 877, 590, 1029, 16073, 20798, 1826, 1707, 331, 653, - 1834, -3080, 1710, 1944, 24998, 20273, 20273, 948, 1034, 20273, - 996, 79, -3080, -3080, -3080, 1769, 56697, 52206, 981, 1006, - 1490, 1578, 1494, 393, 1918, -3080, 1495, -3080, 1582, 56697, - 73603, 219, -3080, 1965, 219, 219, 816, 1972, 1595, 279, - 1767, 46, 434, 1495, 2820, -3080, 54202, 271, 69, 1495, - 56697, 1619, 114, 1495, 1938, 66662, 1267, -3080, -3080, 42881, - 1529, -3080, -3080, -3080, 174, 15023, -3080, 1268, 1280, 1336, - 414, 185, 1535, 1543, 15023, 1552, 1563, 176, 1605, 1659, - 1693, 1763, 1777, 1790, 1802, 1805, 151, 1814, 1819, 1831, - 1842, 1847, 1860, -3080, 1865, 190, 1884, 228, 15023, 1889, - -3080, 1534, 47033, 0, -3080, -3080, 1892, 192, -3080, 47133, - -3080, 1832, 1629, 1630, 66662, 1579, 56697, 1685, 1754, 1910, - 1963, 72136, 1791, -3080, 1869, 56697, 1795, 2820, 1798, 1556, - 2035, 1801, 1156, 1806, 1564, -3080, 70155, 49212, -3080, -3080, - -3080, -3080, -3080, 1931, 1912, 66662, 49212, 1568, -3080, -3080, - 66662, -3080, 56697, 56697, -3080, 56697, 66662, -3080, 852, 47033, - 2074, 806, 74076, 50709, -3080, -3080, -3080, -3080, 842, 885, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, 953, - 49212, -3080, 3716, 45936, 1570, 20273, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, 1571, 1919, -3080, - -3080, 6931, 1573, 46231, 1575, 24998, 24998, 641, 2250, -3080, - -3080, 24998, 1576, 51208, 45850, 1574, 1585, 46416, 16598, 20273, - 16598, 16598, 46482, -3080, 1587, 46571, 61687, 1580, 56697, 30202, - -3080, -3080, -3080, 20273, 20273, 2103, 56198, 1631, 1590, -3080, - -3080, -3080, 32704, -3080, 32704, -3080, 1882, 32704, -3080, -3080, - 1810, -3080, 32704, 1886, 20273, 32704, -3080, 32704, 1830, 1833, - 1598, 32704, -3080, 56697, 1599, 56697, -3080, -3080, 47033, -3080, - 1592, 868, 1611, -3080, -3080, -3080, -3080, -3080, 1652, -3080, - 1652, 1652, -3080, -3080, -3080, -3080, 1616, 1616, 1623, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, 1624, 1072, -3080, 1652, -3080, 1616, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, 73603, -3080, -3080, -3080, -3080, - 631, 637, -3080, 1626, -3080, -3080, 1632, -3080, 1627, 2096, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, 8831, - 888, 1616, -3080, -3080, 3392, -3080, -3080, 20273, 20273, -3080, - -3080, 1638, 47033, 1646, -3080, -3080, 20273, 20273, -3080, -3080, - -3080, -3080, 2127, -3080, 20273, 1652, 1652, -3080, 45868, -3080, - 41691, 17123, 1717, 1719, 2127, -3080, 2127, -3080, 45868, 2140, - 2140, 1641, 37198, -3080, 1808, 46780, -3080, 1643, 1676, 7616, - 1639, -3080, -3080, 1642, -3080, 1647, 1636, 43818, 20273, 191, - 641, 641, 20273, -3080, 2127, 20273, 9061, 9061, -3080, 217, - 71652, 20273, 20273, 20273, 20273, 20273, 20273, 20273, 20273, 47715, - 1739, 186, 66662, 20273, 20273, 29692, 999, -3080, 20273, 1895, - -3080, 1654, 20273, 1747, 325, 20273, 20273, 20273, 20273, 20273, - 20273, 20273, 20273, 20273, -3080, -3080, 28673, 220, 664, 1998, - 2018, -26, 432, 20273, 2010, 11348, -3080, 2010, -3080, -3080, - -3080, -3080, -3080, 230, -3080, -3080, 1592, 1592, 66662, -3080, - 56697, 333, 53204, 20273, -3080, -3080, 1661, 1665, 181, 1729, - -3080, -3080, 56697, -3080, 40192, 1973, -3080, 342, 1668, -3080, - 45811, 1921, 1973, 97, -3080, -3080, 26048, 1807, 1974, 1909, - -3080, -3080, 1890, 1893, -3080, 1680, 47222, 21323, 21323, -3080, - 886, 47033, 900, -3080, -3080, -3080, -3080, -3080, -3080, 1007, - -3080, 56697, 100, 37697, -3080, 1694, 99, -3080, 3147, 2026, - 1995, 1826, 653, 1698, -3080, 57196, 57196, -3080, -3080, 1683, - 1703, 70654, 56697, 1996, 1947, 1999, 400, 71652, -3080, -3080, - -3080, -3080, 56697, 66662, 65180, 71153, 49711, 56697, 49212, -3080, - -3080, -3080, -3080, 56697, 1003, 56697, 6450, -3080, -3080, -3080, - -3080, 219, -3080, -3080, -3080, -3080, -3080, 66662, 56697, -3080, - -3080, 219, 66662, 56697, 219, -3080, 1748, 56697, 56697, 56697, - 56697, 1773, 56697, 56697, 953, -3080, -3080, -3080, 21848, 73, - 73, 1929, -3080, 12923, 165, -3080, 20273, 20273, 871, 299, - 66662, 1897, -3080, -3080, 889, 1948, 144, -3080, 66662, 1762, - 56697, 56697, 56697, 56697, 56697, 625, -3080, -3080, -3080, -3080, - -3080, 1720, -3080, 2085, 2236, 1722, 1724, 2091, -3080, 2820, - 2095, 52705, 670, 2069, 2097, 1768, 2099, 13448, -3080, -3080, - 1731, -3080, -3080, 1732, 2216, 1982, -3080, -3080, 1978, -3080, - 66662, 2261, -3080, 123, -3080, 49212, -3080, 194, -3080, 1983, - 211, -3080, 15023, 20273, -3080, -3080, -3080, -3080, -3080, -3080, - 1267, 29183, -3080, 901, -3080, -3080, 2234, 953, 2234, 615, - -3080, -3080, 2234, -3080, 2221, 2234, -3080, 71652, -3080, 7664, - -3080, 20273, 20273, -3080, 20273, 2109, -3080, 2264, 2264, 71652, - 24998, 24998, 24998, 24998, 24998, 24998, 225, 1443, 24998, 24998, - 24998, 24998, 24998, 24998, 24998, 24998, 24998, 26573, 438, -3080, - -3080, 911, 2242, 20273, 20273, 2116, 2109, 20273, -3080, 71652, - 1765, -3080, 1766, 1771, 20273, -3080, 71652, -3080, 56697, 1776, - -3080, -3080, -3080, 67, 1778, 1797, -3080, -3080, 1617, -3080, - 837, 863, 56697, 3629, 3898, 4357, -3080, -3080, 20273, 2106, - -3080, 1810, 1810, 32704, -3080, 20273, 1799, -3080, -3080, 32704, - 2121, -3080, 1810, -3080, -3080, 38196, 1810, 71652, 957, -3080, - 56697, 71652, 967, 20273, -3080, 15023, 2286, 71652, 2274, 66662, - 66662, 2316, 1804, 1809, 2127, 1896, -3080, 1898, 1900, 1901, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - 71652, -3080, -3080, 308, -3080, -3080, -3080, -3080, -3080, -3080, - 1815, 1816, 20273, 20273, 120, -3080, 8235, 1817, 1818, 6158, - -3080, 1813, -3080, 1812, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - -3080, 1803, -3080, 1823, -3080, 1824, 1825, 1843, 1827, 1840, - 20273, 56697, -3080, 1829, 22373, 1992, 66662, -3080, -3080, 20273, - 20273, 56697, -3080, 2199, 47033, -3080, 1845, 1846, 8765, -3080, - -3080, -3080, 238, 386, 7136, 432, 1232, 1232, 1232, 45868, - -3080, -3080, -3080, 1850, -3080, 24998, 24998, -3080, 1255, 4687, - 10298, -3080, -3080, -3080, -3080, 2189, -3080, 947, -3080, 1844, - -3080, -3080, 5027, -3080, 41691, 7683, 20273, 195, -3080, 20273, - 29692, 20273, 1935, 1232, 1232, 1232, 295, 295, 238, 238, - 238, 386, 432, -3080, -3080, -3080, 1849, 20273, 49212, -3080, - 1851, 1853, 2213, 1450, 20273, -3080, -3080, 32704, 1631, 0, - 1631, 2127, 9061, -3080, 996, -3080, 996, -3080, 47033, 56697, - -3080, -3080, 2124, 1857, 32704, 1903, 2337, 2319, 66662, -3080, - -3080, 1859, 2010, 1875, -3080, -3080, 1887, 20273, 1793, 1887, - -3080, 1973, 14, 2098, 1088, 1088, 886, 2100, -3080, -3080, - 1933, -3080, -3080, -3080, 20273, 13973, 907, -3080, 1393, -3080, - -3080, -3080, -3080, -3080, 1866, -3080, 2150, -3080, 56697, -3080, - -3080, 24998, 2336, 20273, 38695, 2342, 2130, -3080, -3080, -3080, - 1937, 1937, -3080, -3080, 1979, 1495, 20273, 2128, -3080, 156, - 1891, 2252, 603, 2205, 66662, -3080, 341, 368, -3080, 200, - 2259, 211, 2260, 211, 49212, 49212, 49212, 986, -3080, -3080, - -3080, 953, -3080, 364, 1004, -3080, -3080, -3080, -3080, 1985, - 663, 1495, 2820, -3080, -3080, -3080, -3080, -3080, -3080, -3080, - 273, 667, 1495, 1986, -3080, 1988, -3080, 1989, 671, 1495, - -3080, -3080, 1612, 17648, 47033, 511, 165, 165, 165, 15023, - -3080, 2139, 2141, 1905, 47033, 47033, 153, -3080, -3080, -3080, - -3080, 1911, -3080, 234, -3080, 66662, -3080, -3080, -3080, 1897, - 1963, 1869, 56697, 2820, 1913, 2390, 1156, 1564, -3080, 2077, - 426, 1606, -3080, 66662, -3080, 49212, 66662, 56697, 56697, 56697, - 65679, -3080, -3080, -3080, 1914, 1915, -3080, 24, 2146, 2145, - 56697, 1956, 56697, 1494, 2398, 56697, -3080, 1009, 1564, 1564, - 18173, 2288, 56697, 1912, -3080, -3080, -3080, -3080, 66662, -3080, - -3080, 47033, -3080, 1916, -3080, 20273, 50210, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, 49212, -3080, 953, -3080, 953, 2161, - 66662, 44317, 953, 44816, 953, 1923, -3080, 47033, 8870, 47033, - 2116, -3080, 237, 2264, 311, 311, 311, 2474, 2275, 328, - 1930, 311, 311, 311, 255, 255, 237, 237, 237, 2264, - 438, 936, 51208, 1932, -3080, 47033, 47033, -3080, -3080, 1939, - -3080, -3080, -3080, -3080, 1941, 1942, -3080, -3080, -3080, -3080, - 66662, 173, 1631, 239, 239, 239, 239, -3080, 56697, 56697, - 56697, 47033, 2394, 2270, -3080, -3080, 1810, 47033, 56697, -3080, - 27623, -3080, 56697, -3080, 2295, -3080, 2383, -3080, 56697, 1010, - -3080, -3080, -3080, 1015, 1949, 1809, 71652, 1024, 1039, -3080, - 2127, 167, 1945, 1644, 866, 798, 1537, -3080, 54202, -3080, - -3080, 1951, 46837, 20273, -3080, 2325, -3080, -3080, -3080, 20273, - 20273, -3080, 41691, -3080, -3080, -3080, -3080, 370, 370, 8950, - 1829, 1954, 1959, 56697, 10298, 46924, -3080, 39194, -3080, -3080, - 2272, 1958, -3080, 9060, 47033, -3080, 1808, -3080, -3080, 9061, - 20273, 3167, 3242, 20273, 1962, 20273, 2297, -3080, -3080, 1955, - -3080, -3080, 71652, 20273, 1968, 6913, 24998, 24998, 7013, -3080, - 7236, 20273, 10298, -3080, 42968, 1980, 1991, 1929, 18698, -3080, - 2195, 1975, -3080, 2106, 165, 2106, 2001, -3080, -3080, -3080, - -3080, 3392, -3080, 20273, 2153, 66662, 527, 2877, 1050, -3080, - 641, 40192, 1903, 20273, 246, -3080, -3080, 1993, -3080, 1887, - -3080, -3080, -3080, 2210, -3080, -3080, -3080, 56697, -3080, 2006, - -3080, 37697, 2326, 10823, -3080, 37697, 56697, -3080, -3080, 56697, - 42198, 2363, -3080, 66662, 66662, 66662, -3080, 66662, 2005, 2009, - 692, 2000, 781, -3080, 2561, 692, 2353, 307, 1494, 279, - 5359, 401, -3080, -3080, -3080, 2089, 56697, -3080, 66662, -3080, - -3080, -3080, -3080, -3080, 49711, -3080, -3080, 41191, 49212, -3080, - 49212, 56697, 56697, 56697, 56697, 56697, 56697, 56697, 56697, 56697, - 56697, 1267, 20273, -3080, 20273, 2014, 2015, 2016, 1929, -3080, - -3080, -3080, 280, -3080, 2019, -3080, -3080, -3080, 434, -3080, - 234, 2022, 2025, -3080, 52705, 1994, 1768, -3080, 1732, 1963, - 867, 66163, -3080, 2017, 2023, 1869, 1080, 1085, 2820, 2029, - 2511, -3080, 670, 52705, -3080, -3080, -3080, 2458, -3080, 743, - 242, -3080, 1156, -3080, 1994, 1564, -3080, -3080, 2512, -3080, - 2514, 1994, 47033, 66662, 2102, -3080, 211, 1093, -3080, -3080, - -3080, -3080, -3080, 66662, 2038, -3080, 2038, -3080, -3080, 2038, - -3080, -3080, -3080, -3080, 24998, 2389, 2045, 71652, -3080, -3080, - 56697, -3080, -3080, -3080, 1095, 2048, 2106, 56697, 56697, 56697, - 56697, -3080, -3080, -3080, 19223, 20273, 2093, -3080, 2049, 11873, - 2365, -3080, 27098, -3080, -3080, 2057, 38196, 66662, -3080, -3080, - -3080, -3080, 2127, -3080, -3080, 66662, -3080, 2060, -3080, 2061, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, 20273, - 47033, -3080, 47033, -3080, -3080, -3080, -3080, -3080, 56697, -3080, - -3080, 7065, -3080, 2058, 2065, 66662, 56697, 140, -3080, 20273, - 66662, -3080, 1992, -3080, 389, 20273, 20273, 1255, -3080, 43246, - 20273, 71652, 1108, 1255, 252, 20273, 3830, 4216, 20273, 20273, - 8099, 42237, -3080, 22898, 14498, -3080, 2066, 20273, 42276, 40691, - -3080, 32704, 2270, 2067, 2270, 953, 2070, 47033, 20273, -3080, - -3080, -3080, -3080, 2125, 32, 34700, 2289, -3080, 2084, 66662, - -3080, 2153, 47033, -3080, -3080, 41691, -3080, -3080, -3080, -3080, - -3080, 2536, 2083, 2078, 2079, -3080, 1455, -3080, -3080, 66662, - 2081, -3080, 2082, 692, -3080, 66662, 2122, -3080, 269, 2399, - 125, -3080, 20273, -3080, 2490, 2569, 2561, 2092, 66662, 56697, - 24998, -3080, 275, 254, -3080, 2387, 56697, 2122, 2529, -3080, - -3080, -3080, 781, -3080, 2427, 2340, -3080, 219, -3080, 20273, - 781, 2345, 267, 66662, -3080, -3080, 2154, -3080, 71652, 211, - 211, -3080, 1611, 2110, 2112, 2120, 2123, 2131, 2135, 2136, - 2137, 2138, 2143, -3080, 2144, 2148, 2149, 2152, 2155, 2159, - 2169, 2170, 1624, 2171, -3080, 2172, 1993, 2173, 2174, 2175, - 2177, 2178, 72620, 2179, 2181, 2182, 2184, 1626, 2185, 842, - 885, -3080, -3080, -3080, -3080, -3080, -3080, 1198, 2186, -3080, - 2115, -3080, -3080, -3080, 2198, -3080, 2217, -3080, -3080, -3080, - -3080, -3080, -3080, 2119, 2133, -3080, -3080, -3080, 165, 2142, - 2147, 66662, 1267, 119, 49212, 66662, 2162, 1956, 2604, 944, - 2372, 2156, -3080, 953, 2192, -3080, 1768, -3080, 52705, 2420, - 258, 2145, -3080, 264, 1956, -3080, 2552, 1768, 2180, -3080, - 1732, 2246, 20273, 159, -3080, 2417, 66662, 2193, -3080, -3080, - 50210, 2038, 4502, 24998, 71652, 1110, 1148, -3080, 2703, 2360, - 2270, -3080, -3080, -3080, -3080, -3080, 2197, 12, 2207, 9773, - 2204, -3080, -3080, -3080, -3080, -3080, -3080, 47033, 47033, 66662, - 2396, -3080, -3080, 2211, 2215, 39693, 2679, 2222, -3080, -3080, - 2544, -3080, 31205, -3080, 1809, 2241, 1809, 71652, 1809, -3080, - -3080, 47033, 1829, 20273, -3080, -3080, -3080, 2243, 2253, 66662, - 43265, 2577, -3080, -3080, 1255, 1255, 43246, 1172, -3080, 1255, - 20273, 20273, 1255, 1255, 20273, -3080, 19748, 616, -3080, 1180, - -3080, 42324, -3080, 73104, -3080, -3080, 2093, 953, 2093, -3080, - -3080, 2254, -3080, -3080, -3080, 2312, -3080, -3080, 1194, 2684, - 2153, 20273, -3080, -3080, 2262, 37697, -3080, -3080, -3080, -3080, - 37697, 692, -3080, 2431, 2122, 2266, -3080, -3080, -3080, -3080, - -3080, -3080, 42363, -3080, 82, 20273, -3080, 160, 2474, -3080, - -3080, -3080, -3080, 2122, 1156, -3080, 56697, 2740, 2630, -3080, - -3080, 47033, -3080, -3080, 2127, 2127, -3080, -3080, 2383, -3080, - -3080, -3080, 2265, -3080, -3080, 1198, 204, 41191, 56697, 56697, - -3080, -3080, 2267, -3080, -3080, -3080, -3080, -3080, 434, 2665, - 1201, 1205, 670, -3080, 1994, 56697, 2638, 52705, -3080, 49212, - 2753, 2277, 56697, 1956, 433, 433, -3080, 2428, -3080, 2429, - -3080, -3080, 2759, 320, -3080, 1401, 56697, -3080, -3080, 34201, - -3080, 4502, 1206, -3080, -3080, 2281, 2283, -3080, 2093, 20273, - 2287, 20273, -3080, 23423, 2764, 2284, -3080, 20273, 2351, 28148, - -3080, 20273, -3080, 56697, 61687, 2291, 61687, -3080, -3080, -3080, - -3080, 56697, -3080, -3080, -3080, 20273, -3080, 1255, 1255, 1255, - 20273, -3080, 20273, -3080, -3080, -3080, 2500, 2396, -3080, 2396, - 20273, 1994, 641, 2653, 66662, 13, -3080, 47033, -3080, -3080, - -3080, 56697, -3080, 49212, -3080, 692, 354, 2296, 20273, 42716, - 2535, -3080, -3080, 2567, -3080, 2626, -3080, 2361, 323, 2378, - -3080, -3080, -3080, -3080, 1267, 953, -3080, 1768, 2145, 2180, - 2303, 56697, 1207, 1994, 670, 743, -3080, -3080, -3080, -3080, - -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, -3080, 1994, - 2749, 2531, 2754, -3080, 2102, 20273, 145, -3080, 1230, 2747, - -3080, -3080, 2821, 2396, 2310, 23423, 2313, -3080, 2315, 66662, - 47033, 2460, -3080, -3080, 2318, -3080, -3080, 20273, -3080, -3080, - 43322, 2317, 2321, 2776, 1929, 2351, 2351, -3080, 32, -3080, - -3080, 2750, 34201, 2707, 1156, 692, 2338, 1231, -3080, -3080, - -3080, -3080, -3080, 2820, -3080, 42803, 2571, 623, 2556, 2296, - 20273, -3080, 2405, -3080, -3080, -3080, 2810, -3080, -3080, 52705, - 2333, -3080, 2180, 2145, 1956, 2180, 2559, -3080, 2562, 2346, - 42842, 66662, 66662, 1768, 34201, 66662, 2344, 2351, -3080, 2350, - -3080, -3080, -3080, 30202, -3080, 2354, -3080, -3080, -3080, 20273, - 136, -3080, -3080, 2403, 56697, 1241, 87, 2567, 41191, -3080, - 49212, 1022, 354, 2651, -3080, -3080, -3080, -3080, 124, 2587, - -3080, 2588, -3080, 47033, -3080, 1994, 52705, -3080, -3080, -3080, - -3080, -3080, -3080, 34201, 2747, -3080, 342, -3080, 1631, -3080, - 342, -3080, -3080, -3080, -3080, -3080, 1574, 23948, 23948, 23948, - 2370, 1994, -3080, 1631, -3080, 2493, 2556, -3080, -3080, -3080, - -3080, -3080, 270, 270, 2757, -3080, 2430, -3080, 2180, 1253, - 66662, 1887, -3080, 1887, 25523, 2523, 222, 45889, 2744, -3080, - 2744, 2744, -3080, -3080, -3080, 40192, -3080, -3080, 2868, -3080, - 248, -3080, -3080, -3080, 1768, 342, -3080, -3080, 2858, -3080, - -3080, -3080, -3080, -3080, 236, -3080, -3080, -3080, 1631, 692, - -3080, -3080, -3080, 1631, 1887, 24473, 2527, -3080, 2598, -3080, - -3080, -3080, -3080, -3080, -3080, -3080 + 6054, 348, 823, -3162, -3162, 279, 348, 51623, 66578, 339, + 348, 118, 2095, 53619, -3162, -3162, 48130, 8709, 348, 56613, + 73974, 548, 689, 32620, 719, 57112, -3162, -3162, -3162, 66578, + 56613, 57611, 348, 359, 67077, -3162, 348, 35616, 54118, 453, + -3162, 56613, 47, 383, 58110, 56613, 3130, 946, 431, -3162, + -3162, -3162, -3162, -3162, 128, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, 159, -3162, 98, 174, 32620, 32620, 2484, 438, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, 498, + -3162, -3162, 807, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, 35116, -3162, -3162, -3162, -3162, -3162, -3162, 58609, 56613, + 59108, 54617, 59607, -3162, 727, 1020, 705, 152, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + 170, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, 512, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, 182, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, 399, -3162, 535, -3162, 188, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, 1886, -3162, -3162, 961, 2952, + 56613, 715, 753, 724, -3162, 60106, -3162, 712, 56613, -3162, + -3162, 729, 1039, 901, -3162, -3162, 55116, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, 48629, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, 868, -3162, -3162, 688, -3162, 124, -3162, -3162, + 709, 686, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, 791, -3162, -3162, -3162, 805, 67576, 60605, 61104, -3162, + 674, 2617, 9200, 73992, 31620, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, 498, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, 57112, 66578, + 720, 731, 1013, 736, 33618, 771, 36116, 776, 802, 1032, + 810, 814, 824, 841, 383, 32120, 699, 399, 704, 61603, + 61603, -22, 33119, 3628, -3162, 61603, 62102, -3162, 798, -3162, + 1020, -3162, -3162, -3162, -3162, -99, 845, -3162, 62601, 62601, + 62601, 836, 1087, 62601, -3162, -3162, -3162, 878, -3162, -3162, + 1097, 20189, 20189, 68075, 68075, 1020, 68075, 916, 68075, -3162, + -3162, 76, 705, -3162, 399, -3162, -3162, 2484, -3162, -3162, + 54118, -3162, -3162, 270, 1250, 20189, 56613, 926, -3162, 920, + 926, 936, 949, 977, -3162, 6054, 1328, 1209, 55615, 369, + 369, 1467, 369, 662, 701, 2582, 2099, -3162, 1234, -3162, + 1015, -3162, 56613, 57112, 1116, 1042, 1323, -3162, -3162, 1400, + 786, 1204, 1423, 1991, 1431, 788, 1434, 1240, 1440, 1532, + 31, -3162, 20189, 49128, 399, -3162, 11264, 20189, -3162, -3162, + -3162, 1176, -3162, -3162, -3162, -3162, -3162, 56613, 66578, 1108, + 1132, -3162, -3162, -3162, -3162, 1530, 1377, -3162, 1614, 68574, + -3162, -3162, 1197, 63100, 63599, 64098, 64597, 1585, -3162, -3162, + 1525, -3162, -3162, -3162, 1199, -3162, -3162, -3162, 168, 69073, + 1534, 1168, 105, -3162, 1547, 119, -3162, 1562, 1426, 14939, + -3162, 1363, -3162, -3162, -3162, 383, -3162, 377, -3162, -3162, + 45231, -3162, -3162, 73992, 1293, 1210, -3162, 20189, 20189, 1214, + 6413, 61603, 62102, 20189, 56613, -3162, 20189, 24914, 1218, 20189, + 20189, 12314, 20189, 30622, 61603, 3628, 1207, -3162, 567, -3162, + 56613, 1225, -3162, 1324, 1324, 359, 32620, 1546, 32120, 1324, + 1324, 1324, -3162, 1035, 1539, 1452, -3162, 32620, 1452, 1502, + 1254, 1572, 1452, -3162, 261, 1579, 1324, 36615, 1262, -3162, + 1324, 1512, -3162, -3162, 20189, 14939, 71568, 1784, -3162, -3162, + -3162, -3162, 1591, -3162, 66578, 1318, -3162, -3162, -3162, -3162, + -3162, -3162, 772, 1845, 165, 1851, 20189, 165, 165, 1339, + 190, 190, -3162, 1538, 1341, -3162, 198, 1347, 1349, 1863, + 1864, 167, 147, 1028, 165, 20189, -3162, 190, 1352, 1866, + 1356, 1868, 197, 207, -3162, 201, 20189, 20189, 20189, 305, + 20189, 10214, -3162, 49128, 1867, 56613, 590, -3162, 399, 1359, + 1020, -3162, -3162, -3162, -3162, -3162, -3162, -3162, 1360, -3162, + 185, 7096, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + 1394, -3162, -3162, -3162, -3162, 1577, 20189, -3162, -3162, 1358, + 1546, -3162, 205, -3162, -3162, 1546, -3162, -3162, -3162, -3162, + -3162, 218, -3162, 1779, 20189, 20189, -3162, 399, 69572, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, 536, -3162, 498, 515, + 46949, 1362, 1367, 926, 56613, 56613, 1847, -3162, -3162, -3162, + -3162, 54118, 144, 1668, 169, 1504, -3162, -3162, 2484, 2484, + 15464, 1290, 222, 549, 15989, 20714, 1724, 1607, 213, 600, + 1729, -3162, 1615, 1840, 24914, 20189, 20189, 662, 701, 20189, + 920, 122, -3162, -3162, -3162, 1665, 56613, 52122, 334, 778, + 1387, 1476, 1390, 91, 1816, -3162, 1389, -3162, 1482, 56613, + 73519, 226, -3162, 1856, 226, 226, 245, 1857, 1486, 233, + 1652, 67, -83, 1389, 4318, -3162, 54118, 150, 738, 1389, + 56613, 1488, 822, 1389, 1812, 66578, 1210, -3162, -3162, 42797, + 1398, -3162, -3162, -3162, 186, 14939, -3162, 971, 1202, 1208, + 367, 212, 1248, 1263, 14939, 1269, 1355, 200, 1361, 1380, + 1450, 1505, 1554, 1596, 1602, 1618, 134, 1643, 1666, 1680, + 1693, 1699, 1721, -3162, 1725, 202, 1727, 215, 14939, 1755, + -3162, 146, 46949, -1, -3162, -3162, 1761, 204, -3162, 47049, + -3162, 1701, 1493, 1494, 66578, 1448, 56613, 1550, 1422, 1780, + 1831, 72052, 1658, -3162, 1757, 56613, 1679, 4318, 1682, 1442, + 1921, 1688, 1132, 1691, 1449, -3162, 70071, 49128, -3162, -3162, + -3162, -3162, -3162, 1818, 1802, 66578, 49128, 1455, -3162, -3162, + 66578, -3162, 56613, 56613, -3162, 56613, 66578, -3162, 542, 46949, + 1963, 1022, 73992, 50625, -3162, -3162, -3162, -3162, 933, 939, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, 1020, + 49128, -3162, 3393, 45852, 1458, 20189, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, 1461, 1811, -3162, + -3162, 6931, 1465, 46147, 1468, 24914, 24914, 399, 2469, -3162, + -3162, 24914, 1469, 51124, 45766, 1464, 1470, 46332, 16514, 20189, + 16514, 16514, 46398, -3162, 1471, 46487, 61603, 1473, 56613, 30118, + -3162, -3162, -3162, 20189, 20189, 3628, 56114, 1515, 1477, -3162, + -3162, -3162, 32620, -3162, 32620, -3162, 1770, 32620, -3162, -3162, + 3794, -3162, 32620, 1772, 20189, 32620, -3162, 32620, 1717, 1719, + 1485, 32620, -3162, 56613, 1487, 56613, -3162, -3162, 46949, -3162, + 1484, 586, 1489, -3162, -3162, -3162, -3162, -3162, 1541, -3162, + 1541, 1541, -3162, -3162, -3162, -3162, 1492, 1492, 1495, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, 1496, 1028, -3162, 1541, -3162, 1492, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, 73519, -3162, -3162, -3162, -3162, + -92, -79, -3162, 1497, -3162, -3162, 1501, -3162, 1506, 1985, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, 8118, + 687, 1492, -3162, -3162, 4489, -3162, -3162, 20189, 20189, -3162, + -3162, 1507, 46949, 1552, -3162, -3162, 20189, 20189, -3162, -3162, + -3162, -3162, 2020, -3162, 20189, 1541, 1541, -3162, 6264, -3162, + 41607, 17039, 1601, 1604, 2020, -3162, 2020, -3162, 6264, 2021, + 2021, 1517, 37114, -3162, 1681, 46696, -3162, 1523, 1555, 7666, + 1520, -3162, -3162, 1524, -3162, 1526, 1518, 43734, 20189, 178, + 399, 399, 20189, -3162, 2020, 20189, 9122, 9122, -3162, 224, + 71568, 20189, 20189, 20189, 20189, 20189, 20189, 20189, 20189, 47631, + 1621, 136, 66578, 20189, 20189, 29608, 984, -3162, 20189, 1782, + -3162, 1548, 20189, 1628, 253, 20189, 20189, 20189, 20189, 20189, + 20189, 20189, 20189, 20189, -3162, -3162, 28589, 308, 520, 1871, + 1901, -10, 538, 20189, 1893, 11264, -3162, 1893, -3162, -3162, + -3162, -3162, -3162, 206, -3162, -3162, 1484, 1484, 66578, -3162, + 56613, 270, 53120, 20189, -3162, -3162, 1545, 1549, 599, 1612, + -3162, -3162, 56613, -3162, 40108, 1852, -3162, 332, 1558, -3162, + 45727, 1806, 1852, 2484, -3162, -3162, 25964, 1684, 1854, 1791, + -3162, -3162, 1771, 1774, -3162, 1561, 47138, 21239, 21239, -3162, + 1409, 46949, 1414, -3162, -3162, -3162, -3162, -3162, -3162, 671, + -3162, 56613, 99, 37613, -3162, 1563, 164, -3162, 2765, 1909, + 1872, 1724, 600, 1574, -3162, 57112, 57112, -3162, -3162, 1255, + 1573, 70570, 56613, 1869, 1819, 1873, -64, 71568, -3162, -3162, + -3162, -3162, 56613, 66578, 65096, 71069, 49627, 56613, 49128, -3162, + -3162, -3162, -3162, 56613, 890, 56613, 3834, -3162, -3162, -3162, + -3162, 226, -3162, -3162, -3162, -3162, -3162, 66578, 56613, -3162, + -3162, 226, 66578, 56613, 226, -3162, 1260, 56613, 56613, 56613, + 56613, 1332, 56613, 56613, 1020, -3162, -3162, -3162, 21764, 37, + 37, 1805, 1821, 1824, 1588, 12839, 146, -3162, 20189, 20189, + 325, 295, 66578, 1777, -3162, -3162, 692, 1832, 109, -3162, + 66578, 1649, 56613, 56613, 56613, 56613, 56613, 2508, -3162, -3162, + -3162, -3162, -3162, 1605, -3162, 1969, 2119, 1606, 1609, 1977, + -3162, 4318, 1981, 52621, 866, 3367, 1982, 1659, 1986, 13364, + -3162, -3162, 1622, -3162, -3162, 1624, 2107, 1874, -3162, -3162, + 1862, -3162, 66578, 2150, -3162, 105, -3162, 49128, -3162, 119, + -3162, 1870, 214, -3162, 14939, 20189, -3162, -3162, -3162, -3162, + -3162, -3162, 1210, 29099, -3162, 713, -3162, -3162, 2118, 1020, + 2118, 497, -3162, -3162, 2118, -3162, 2102, 2118, -3162, 71568, + -3162, 8056, -3162, 20189, 20189, -3162, 20189, 1990, -3162, 2152, + 2152, 71568, 24914, 24914, 24914, 24914, 24914, 24914, 199, 1352, + 24914, 24914, 24914, 24914, 24914, 24914, 24914, 24914, 24914, 26489, + 622, -3162, -3162, 749, 2125, 20189, 20189, 1999, 1990, 20189, + -3162, 71568, 1650, -3162, 1655, 1657, 20189, -3162, 71568, -3162, + 56613, 1661, -3162, -3162, -3162, 48, 1653, 1663, -3162, -3162, + 1546, -3162, 1060, 1064, 56613, 1978, 3821, 4733, -3162, -3162, + 20189, 1987, -3162, 3794, 3794, 32620, -3162, 20189, 1667, -3162, + -3162, 32620, 2010, -3162, 3794, -3162, -3162, 38112, 3794, 71568, + 756, -3162, 56613, 71568, 777, 20189, -3162, 14939, 2180, 71568, + 2145, 66578, 66578, 2184, 1672, 1673, 2020, 1759, -3162, 1763, + 1764, 1767, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, 71568, -3162, -3162, 158, -3162, -3162, -3162, -3162, + -3162, -3162, 1683, 1675, 20189, 20189, 62, -3162, 8203, 1687, + 1690, 6565, -3162, 1685, -3162, 1686, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, -3162, 1697, -3162, 1694, -3162, 1700, 1702, 1709, + 1704, 1705, 20189, 56613, -3162, 1698, 22289, 1848, 66578, -3162, + -3162, 20189, 20189, 56613, -3162, 2072, 46949, -3162, 1706, 1707, + 8647, -3162, -3162, -3162, 252, 737, 6322, 538, 3743, 3743, + 3743, 6264, -3162, -3162, -3162, 1731, -3162, 24914, 24914, -3162, + 4673, 3933, 10214, -3162, -3162, -3162, -3162, 2056, -3162, 665, + -3162, 1716, -3162, -3162, 4655, -3162, 41607, 7006, 20189, 163, + -3162, 20189, 29608, 20189, 1804, 3743, 3743, 3743, 333, 333, + 252, 252, 252, 737, 538, -3162, -3162, -3162, 1718, 20189, + 49128, -3162, 1720, 1722, 2082, 1356, 20189, -3162, -3162, 32620, + 1515, -1, 1515, 2020, 9122, -3162, 920, -3162, 920, -3162, + 46949, 56613, -3162, -3162, 1993, 1723, 32620, 1768, 2207, 2190, + 66578, -3162, -3162, 1728, 1893, 1744, -3162, -3162, 1750, 20189, + 3187, 1750, -3162, 1852, 19, 1964, 1014, 1014, 1409, 1966, + -3162, -3162, 1800, -3162, -3162, -3162, 20189, 13889, 1416, -3162, + 1420, -3162, -3162, -3162, -3162, -3162, 1736, -3162, 2016, -3162, + 56613, -3162, -3162, 24914, 2203, 20189, 38611, 2204, 2000, -3162, + -3162, -3162, 1798, 1798, -3162, -3162, 1838, 1389, 20189, 1996, + -3162, 115, 1758, 2123, 298, 2079, 66578, -3162, 316, 329, + -3162, 166, 2131, 214, 2132, 214, 49128, 49128, 49128, 779, + -3162, -3162, -3162, 1020, -3162, 12, 784, -3162, -3162, -3162, + -3162, 1858, 892, 1389, 4318, -3162, -3162, -3162, -3162, -3162, + -3162, -3162, 156, 956, 1389, 1859, -3162, 1875, -3162, 1878, + 958, 1389, -3162, -3162, 1532, 17564, 46949, 394, 146, 146, + 146, -3162, -3162, -3162, 14939, -3162, 1775, 46949, 46949, 151, + -3162, -3162, -3162, -3162, 1769, -3162, 352, -3162, 66578, -3162, + -3162, -3162, 1777, 1831, 1757, 56613, 4318, 1781, 2253, 1132, + 1449, -3162, 1940, 23, 902, -3162, 66578, -3162, 49128, 66578, + 56613, 56613, 56613, 65595, -3162, -3162, -3162, 1778, 1793, -3162, + -6, 2013, 2014, 56613, 1823, 56613, 1390, 2273, 56613, -3162, + 793, 1449, 1449, 18089, 2164, 56613, 1802, -3162, -3162, -3162, + -3162, 66578, -3162, -3162, 46949, -3162, 1790, -3162, 20189, 50126, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, 49128, -3162, 1020, + -3162, 1020, 2039, 66578, 44233, 1020, 44732, 1020, 1803, -3162, + 46949, 8811, 46949, 1999, -3162, 230, 2152, 1603, 1603, 1603, + 1289, 2149, 528, 1807, 1603, 1603, 1603, 277, 277, 230, + 230, 230, 2152, 622, 798, 51124, 1808, -3162, 46949, 46949, + -3162, -3162, 1813, -3162, -3162, -3162, -3162, 1814, 1826, -3162, + -3162, -3162, -3162, 66578, 157, 1515, 453, 453, 453, 453, + -3162, 56613, 56613, 56613, 46949, 2264, 2144, -3162, -3162, 3794, + 46949, 56613, -3162, 27539, -3162, 56613, -3162, 2168, -3162, 2257, + -3162, 56613, 800, -3162, -3162, -3162, 819, 1822, 1673, 71568, + 833, 861, -3162, 2020, 145, 1830, 1527, 992, 1075, 1435, + -3162, 54118, -3162, -3162, 1834, 46753, 20189, -3162, 2197, -3162, + -3162, -3162, 20189, 20189, -3162, 41607, -3162, -3162, -3162, -3162, + 131, 131, 8900, 1698, 1820, 1844, 56613, 10214, 46840, -3162, + 39110, -3162, -3162, 2166, 1829, -3162, 8978, 46949, -3162, 1681, + -3162, -3162, 9122, 20189, 2794, 5118, 20189, 1850, 20189, 2198, + -3162, -3162, 1853, -3162, -3162, 71568, 20189, 1855, 5420, 24914, + 24914, 5942, -3162, 6836, 20189, 10214, -3162, 42884, 1865, 1877, + 1805, 18614, -3162, 2084, 1876, -3162, 1987, 146, 1987, 1881, + -3162, -3162, -3162, -3162, 4489, -3162, 20189, 2026, 66578, 505, + 2525, 867, -3162, 399, 40108, 1768, 20189, 553, -3162, -3162, + 1885, -3162, 1750, -3162, -3162, -3162, 2100, -3162, -3162, -3162, + 56613, -3162, 1887, -3162, 37613, 2215, 10739, -3162, 37613, 56613, + -3162, -3162, 56613, 42114, 2252, -3162, 66578, 66578, 66578, -3162, + 66578, 1883, 1888, 266, 1894, 721, -3162, 2619, 266, 2235, + 275, 1390, 233, 2821, 61, -3162, -3162, -3162, 1971, 56613, + -3162, 66578, -3162, -3162, -3162, -3162, -3162, 49627, -3162, -3162, + 41107, 49128, -3162, 49128, 56613, 56613, 56613, 56613, 56613, 56613, + 56613, 56613, 56613, 56613, 1210, 20189, -3162, 20189, 1896, 1898, + 1900, 1805, -3162, 221, -3162, 1903, -3162, -3162, -3162, -83, + -3162, 352, 1902, 1906, -3162, 52621, 2952, 1659, -3162, 1624, + 1831, 379, 66079, -3162, 1907, 1905, 1757, 881, 883, 4318, + 1910, 2390, -3162, 866, 52621, -3162, -3162, -3162, 2345, -3162, + 674, 194, -3162, 1132, -3162, 2952, 1449, -3162, -3162, 2393, + -3162, 2394, 2952, 46949, 66578, 1979, -3162, 214, 889, -3162, + -3162, -3162, -3162, -3162, 66578, 1915, -3162, 1915, -3162, -3162, + 1915, -3162, -3162, -3162, -3162, 24914, 2266, 1924, 71568, -3162, + -3162, 56613, -3162, -3162, -3162, 893, 1926, 1987, 56613, 56613, + 56613, 56613, -3162, -3162, -3162, 19139, 20189, 1967, -3162, 1928, + 11789, 2251, -3162, 27014, -3162, -3162, 1933, 38112, 66578, -3162, + -3162, -3162, -3162, 2020, -3162, -3162, 66578, -3162, 1936, -3162, + 1937, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + 20189, 46949, -3162, 46949, -3162, -3162, -3162, -3162, -3162, 56613, + -3162, -3162, 7517, -3162, 1934, 1941, 66578, 56613, 231, -3162, + 20189, 66578, -3162, 1848, -3162, 390, 20189, 20189, 4673, -3162, + 43162, 20189, 71568, 897, 4673, 353, 20189, 5250, 5349, 20189, + 20189, 7468, 42153, -3162, 22814, 14414, -3162, 1942, 20189, 42192, + 40607, -3162, 32620, 2144, 1943, 2144, 1020, 1945, 46949, 20189, + -3162, -3162, -3162, -3162, 2002, 452, 34616, 2169, -3162, 1959, + 66578, -3162, 2026, 46949, -3162, -3162, 41607, -3162, -3162, -3162, + -3162, -3162, 2408, 2615, 1950, 1951, -3162, 1357, -3162, -3162, + 66578, 1953, -3162, 1955, 266, -3162, 66578, 1998, -3162, 286, + 2274, 117, -3162, 20189, -3162, 2370, 2451, 2619, 1974, 66578, + 56613, 24914, -3162, 302, 223, -3162, 2268, 56613, 1998, 2412, + -3162, -3162, -3162, 721, -3162, 2304, 2221, -3162, 226, -3162, + 20189, 721, 2224, 149, 66578, -3162, -3162, 2171, -3162, 71568, + 214, 214, -3162, 1489, 1988, 1994, 1995, 1997, 2001, 2003, + 2004, 2008, 2009, 2011, -3162, 2012, 2018, 2019, 2022, 2024, + 2025, 2027, 2028, 1496, 2029, -3162, 2032, 1885, 2033, 2034, + 2037, 2038, 2042, 72536, 2043, 2044, 2045, 2046, 1497, 2047, + 933, 939, -3162, -3162, -3162, -3162, -3162, -3162, 1168, 2050, + -3162, 2006, -3162, -3162, -3162, 2074, -3162, 2075, -3162, -3162, + -3162, -3162, -3162, -3162, 2005, 2017, -3162, -3162, -3162, 146, + 1992, 2052, 66578, 1210, 154, 49128, 66578, 2057, 1823, 2493, + 458, 2261, 2062, -3162, 1020, 2064, -3162, 1659, -3162, 52621, + 3754, 636, 2014, -3162, 273, 1823, -3162, 2468, 1659, 2103, + -3162, 1624, 2167, 20189, 155, -3162, 2295, 66578, 2069, -3162, + -3162, 50126, 1915, 5813, 24914, 71568, 908, 913, -3162, 2579, + 2237, 2144, -3162, -3162, -3162, -3162, -3162, 2076, -29, 2080, + 9689, 2078, -3162, -3162, -3162, -3162, -3162, -3162, 46949, 46949, + 66578, 2267, -3162, -3162, 2083, 2085, 39609, 2538, 2087, -3162, + -3162, 2403, -3162, 31121, -3162, 1673, 2091, 1673, 71568, 1673, + -3162, -3162, 46949, 1698, 20189, -3162, -3162, -3162, 2088, 2092, + 66578, 43181, 2421, -3162, -3162, 4673, 4673, 43162, 918, -3162, + 4673, 20189, 20189, 4673, 4673, 20189, -3162, 19664, 413, -3162, + 927, -3162, 42240, -3162, 73020, -3162, -3162, 1967, 1020, 1967, + -3162, -3162, 2098, -3162, -3162, -3162, 2163, -3162, -3162, 960, + 2535, 2026, 20189, -3162, -3162, 2108, 37613, -3162, -3162, -3162, + -3162, 37613, 266, -3162, 2286, 1998, 2117, -3162, -3162, -3162, + -3162, -3162, -3162, 42279, -3162, 79, 20189, -3162, 1038, 1289, + -3162, -3162, -3162, -3162, 1998, 1132, -3162, 56613, 2596, 2489, + -3162, -3162, 46949, -3162, -3162, 2020, 2020, -3162, -3162, 2257, + -3162, -3162, -3162, 2124, -3162, -3162, 1168, 95, 41107, 56613, + 56613, -3162, -3162, 2126, -3162, -3162, -3162, -3162, -3162, -83, + 2524, 983, 994, 866, -3162, 2952, 56613, 2497, 52621, -3162, + 49128, 2611, 2133, 56613, 1823, 1156, 1156, -3162, 2288, -3162, + 2289, -3162, -3162, 2620, 290, -3162, 1341, 56613, -3162, -3162, + 34117, -3162, 5813, 995, -3162, -3162, 2136, 2141, -3162, 1967, + 20189, 2143, 20189, -3162, 23339, 2622, 2142, -3162, 20189, 2206, + 28064, -3162, 20189, -3162, 56613, 61603, 2148, 61603, -3162, -3162, + -3162, -3162, 56613, -3162, -3162, -3162, 20189, -3162, 4673, 4673, + 4673, 20189, -3162, 20189, -3162, -3162, -3162, 2357, 2267, -3162, + 2267, 20189, 2952, 399, 4497, 66578, 18, -3162, 46949, -3162, + -3162, -3162, 56613, -3162, 49128, -3162, 266, -4, 2151, 20189, + 42632, 2392, -3162, -3162, 2429, -3162, 2488, -3162, 2223, 344, + 2240, -3162, -3162, -3162, -3162, 1210, 1020, -3162, 1659, 2014, + 2103, 2174, 56613, 1009, 2952, 866, 674, -3162, -3162, -3162, + -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, -3162, + 2952, 2613, 2396, 2621, -3162, 1979, 20189, 108, -3162, 1029, + 2614, -3162, -3162, 2687, 2267, 2179, 23339, 2183, -3162, 2185, + 66578, 46949, 2335, -3162, -3162, 2194, -3162, -3162, 20189, -3162, + -3162, 43238, 2192, 2199, 2655, 1805, 2206, 2206, -3162, 452, + -3162, -3162, 2629, 34117, 2590, 1132, 266, 2208, 1041, -3162, + -3162, -3162, -3162, -3162, 4318, -3162, 42719, 2455, 129, 2439, + 2151, 20189, -3162, 2290, -3162, -3162, -3162, 2690, -3162, -3162, + 52621, 2213, -3162, 2103, 2014, 1823, 2103, 2440, -3162, 2441, + 2217, 42758, 66578, 66578, 1659, 34117, 66578, 2218, 2206, -3162, + 2220, -3162, -3162, -3162, 30118, -3162, 2225, -3162, -3162, -3162, + 20189, 140, -3162, -3162, 2278, 56613, 1043, 74, 2429, 41107, + -3162, 49128, 1783, -4, 2537, -3162, -3162, -3162, -3162, 102, + 2456, -3162, 2457, -3162, 46949, -3162, 2952, 52621, -3162, -3162, + -3162, -3162, -3162, -3162, 34117, 2614, -3162, 332, -3162, 1515, + -3162, 332, -3162, -3162, -3162, -3162, -3162, 1464, 23864, 23864, + 23864, 2229, 2952, -3162, 1515, -3162, 2361, 2439, -3162, -3162, + -3162, -3162, -3162, 209, 209, 2630, -3162, 2297, -3162, 2103, + 1047, 66578, 1750, -3162, 1750, 25439, 2386, 193, 45805, 2610, + -3162, 2610, 2610, -3162, -3162, -3162, 40108, -3162, -3162, 2732, + -3162, 203, -3162, -3162, -3162, 1659, 332, -3162, -3162, 2723, + -3162, -3162, -3162, -3162, -3162, 162, -3162, -3162, -3162, 1515, + 266, -3162, -3162, -3162, 1515, 1750, 24389, 2397, -3162, 2466, + -3162, -3162, -3162, -3162, -3162, -3162, -3162 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int16 yypgoto[] = { - -3080, -3080, -3080, 2024, 84, -3080, -3080, 243, -3080, 1104, - -3080, 229, -808, 622, -3080, 85, 3904, 2608, 4107, 1047, - -520, -893, -1259, 8, 88, -1157, 7, -3080, -3080, -3080, - -3080, -1518, -429, 296, -3080, -3080, -565, -2606, -518, -3080, - -2977, -3079, -3080, -3080, -664, -3050, -2105, 89, -3080, -3080, - 93, 2, -2151, -3080, -1690, 75, -2134, 102, 104, 1011, - -3080, -2610, 107, -895, -1207, -942, -1215, -3080, -50, -3080, - 521, 112, 1704, 2063, -3080, 3, -2200, -2940, -532, -3080, - -635, -3080, -288, -3080, -582, -3080, -1045, -590, -623, -2869, - -1147, -3080, 1711, -338, -3080, 659, -3080, -2618, -3080, -3080, - 645, -3080, -1172, -3080, -2273, 199, -566, -2422, -2603, -2210, - -917, 282, -573, 259, -2142, -1263, -3080, 668, -3080, -556, - -3080, -889, -2160, 116, -3080, -3080, 1597, -922, -3080, 122, - -3080, 555, -3080, -2136, 556, -2135, 1648, -459, 10, 11, - -3080, -3080, -3080, -3080, -3080, -612, 595, -1225, -3080, 532, - -3080, -3080, -3080, -3080, -133, 244, -2283, 27, 315, -20, - -25, -3080, -18, -3080, -3080, -3080, 699, -3080, -3080, 17, - 61, 1781, -3080, -1035, -3080, -1695, 522, -3080, 1957, 1960, - -2209, -874, -61, -3080, 745, -1676, -2158, -622, 1197, 1775, - 1774, -3080, 489, -2302, -3080, -516, -3080, 332, -3080, -3080, - 740, 1250, -1568, -1571, -3080, -2233, -3080, -428, -315, -3080, - -3080, -3080, -3080, -3080, -2538, -2357, -576, 1221, -3080, 1789, - -3080, -3080, -3080, -3080, 68, -1540, 2967, 787, -3080, 118, - -3080, -3080, -3080, -3080, 198, -3080, 977, -126, -3080, -482, - -683, -800, 2012, -142, 306, -1673, -13, -361, 545, -3080, - -3080, 547, -2116, -1448, 503, -223, 976, -3080, 39, -1264, - -3080, -1883, -1191, -3080, -3080, -667, 1262, -3080, -3080, -3080, - 2655, 2660, -3080, -3080, 2732, 2853, -3080, -913, 2866, 1163, - -1043, 2020, -927, 2021, -936, -932, -941, 2027, 2030, 2031, - 2033, 2036, 2037, 2039, -1557, 5232, -735, 2532, -2188, -3080, - -1439, -1590, 1102, 1103, 1105, 48, -3080, -1410, 210, -3080, - -3080, -3080, -3080, -3080, -2305, -3080, -401, -3080, -393, -3080, - -3080, -3080, -1586, -2939, -1612, -3080, 4057, 908, -3080, -3080, - 495, -3080, -3080, -3080, -3080, -1547, -3080, 6280, 813, -3080, - -2041, -3080, -3080, -981, -837, -517, -1009, -1228, -1946, -3080, - -3080, -3080, -3080, -3080, -3080, -1514, -1791, -57, 872, -3080, - -3080, 964, -3080, -3080, -3080, 183, -1498, -1768, -2143, -3080, - -3080, -3080, 881, 1572, 154, -835, -1642, -3080, -1561, -3080, - -3080, 921, -2410, -3080, -3080, 484, -2661, -3080, -3080, 189, - -3080, -609, -1145, -2495, 64, 25, -3080, 1359, -2591, -3080, - -3080, -727, -2700, -1143, -896, -3080, 126, -3080, 442, 137, - -1672, -3080, 4, -3080, -350, -3080, -3080, -2585, -3080, 139, - 141, 2257, -3080, 1208, -3080, -3080, -3080, -3080, -578, -3080, - -632, -624, -3080, -3080, 20, -904, 1687, -3080, 142, 607, - -3080, 1025, -3080, 810, 146, -3080, 2158, -282, 148, 1353, - -3080, -3080, -3080, 23, -608, 441, -3080, 1355, -3080, -3080, - 1820, 733, 149, -3080, 536, 22, -3080, -3080, -3080, 91, - 150, 5, -3021, 152, -2837, -1691, -7, -3080, -3080, -3080, - -720, -3080, -2581 + -3162, -3162, -3162, 1891, 78, -3162, -3162, 103, -3162, 975, + -3162, 106, -797, 489, -3162, 82, 3221, 2609, 4184, 1298, + -520, -890, -1248, 24, 84, -1138, 3, -3162, -3162, -3162, + -3162, -1516, -560, 173, -3162, -3162, -697, -2619, -650, -3162, + -3037, -3092, -3162, -3162, -786, -3061, -2089, 86, -3162, -3162, + 90, 4, -2178, -3162, -1700, 63, -2168, 93, 94, 888, + -3162, -2620, 96, -884, -1212, -917, -1202, -3162, -169, -3162, + 401, 100, 1828, 1946, -3162, 5, -2220, -2969, -646, -3162, + -748, -3162, -400, -3162, -692, -3162, -730, -700, -729, -2891, + -1155, -3162, 1599, -447, -3162, 547, -3162, -2602, -3162, -3162, + 537, -3162, -1176, -3162, -2268, 88, -676, -2435, -2604, -2212, + -908, 171, -682, 148, -2171, -1048, -3162, 561, -3162, -664, + -3162, -899, -2099, 101, -3162, -3162, 1490, -932, -3162, 104, + -3162, 445, -3162, -2176, 446, -2175, 1519, -562, 8, 10, + -3162, -3162, -3162, -3162, -3162, -691, 487, -1228, -3162, 427, + -3162, -3162, -3162, -3162, -236, 135, -2296, 27, 3629, -44, + -18, -3162, 2, -3162, -3162, -3162, 594, -3162, -3162, 14, + 58, 1674, -3162, -1043, -3162, -1670, 763, -3162, 1841, 1842, + -1782, -875, -55, -3162, 641, -1682, -2174, -639, 1102, 1671, + 1676, -3162, 396, -2574, -3162, -610, -3162, 797, -3162, -3162, + 640, 1152, -1582, -1578, -3162, -2277, -3162, -527, -414, -3162, + -3162, -3162, -3162, -3162, -2576, -2932, -627, 1122, -3162, 1689, + -3162, -3162, -3162, -3162, 50, -1547, 2861, 679, -3162, 68, + -3162, -3162, -3162, -3162, 87, -3162, 870, -232, -3162, -492, + -681, -795, 1904, -496, 13, -1739, -12, -380, 437, -3162, + -3162, 441, -2105, -1445, 400, -329, 873, -3162, -63, -1266, + -3162, -1877, -1198, -3162, -3162, -772, 652, -3162, -3162, -3162, + 1544, 2347, -3162, -3162, 2552, 2561, -3162, -904, 2808, -799, + -1049, 1918, -938, 1919, -941, -928, -915, 1920, 1923, 1925, + 1927, 1929, 1931, 1932, -1548, 5255, -196, 1160, -2204, -3162, + -1430, -1598, 1001, 1003, 1005, 38, -3162, -1422, 210, -3162, + -3162, -3162, -3162, -3162, -2802, -3162, -487, -3162, -484, -3162, + -3162, -3162, -1692, -3161, -1732, -3162, -793, 816, -3162, -3162, + 397, -3162, -3162, -3162, -3162, -1534, -3162, 6195, 717, -3162, + -2037, -3162, -3162, -974, -809, -711, -1014, -1233, -1959, -3162, + -3162, -3162, -3162, -3162, -3162, -1522, -1807, -655, 773, -3162, + -3162, 874, -3162, -3162, -3162, 92, -1436, -1777, -2135, -3162, + -3162, -3162, 780, 1481, 52, -829, -1640, -3162, -1559, -3162, + -3162, 834, -2413, -3162, -3162, 392, -2682, -3162, -3162, 110, + -3162, -623, -1129, -2489, 559, 16, -3162, 1773, -2585, -3162, + -3162, -731, -2722, -1136, -898, -3162, 107, -3162, 350, 112, + -1652, -3162, 6, -3162, -443, -3162, -3162, -2634, -3162, 116, + 130, 2172, -3162, 1114, -3162, -3162, -3162, -3162, -601, -3162, + -630, -632, -3162, -3162, 28, -903, 1594, -3162, 132, 227, + -3162, 935, -3162, 698, 133, -3162, 2065, -408, 137, 1266, + -3162, -3162, -3162, 11, -621, 354, -3162, 1268, -3162, -3162, + 1714, 647, 138, -3162, 289, 17, -3162, -3162, -3162, 83, + 141, 7, -3030, 142, -2808, -1707, -7, -3162, -3162, -3162, + -719, -3162, -2565 }; /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If @@ -4422,3031 +4423,3073 @@ static const yytype_int16 yypgoto[] = #define YYTABLE_NINF -2102 static const yytype_int16 yytable[] = { - 525, 914, 57, 65, 82, 103, 1140, 53, 1244, 719, - 68, 69, 884, 1315, 1207, 1036, 525, 77, 1445, 963, - 1987, 1263, 99, 94, 718, 858, 872, 70, 1172, 1815, - 1707, 1826, 523, 1962, 982, 1814, 1501, 77, 1371, 1798, - 778, 2186, 784, 1354, 2219, 1779, 1318, 2022, 523, 1419, - 1607, 2103, 888, 2092, 1417, 522, 2053, 1862, 1418, 889, - 2325, 2620, 1785, 1415, 856, 2142, 2610, 1764, 525, 525, - 1831, 817, 2593, 1360, 2595, 1789, 1377, 559, 2655, 2119, - 2120, 2503, 2726, 750, 50, 51, 3017, 1894, 52, 55, - 1819, 810, 745, 56, 826, 1243, 3019, 1249, 905, 1253, - 523, 523, 59, 2609, 60, 1684, 870, 61, 869, 869, - 1687, 3046, 63, 2574, 3061, 1263, 66, 2695, 2696, 2697, - 1620, 973, 67, 817, 817, 851, 80, 1014, 898, 3064, - 976, 3048, 2648, 1039, 2842, 2709, 2910, 81, 965, 83, - 2915, 84, 90, 810, 810, 2505, 91, 2190, 93, 98, - 102, 1384, 104, -1373, 1584, 1585, -1949, 2144, 2351, -454, - 2355, 1688, 1364, 821, -2089, -2089, -1949, 1060, -527, 2242, - 2239, 1597, -531, 901, 2457, 2350, 1060, 1980, -371, -1314, - 3139, -1940, 1981, 1061, 537, 3136, 1348, -1311, -1311, -2080, - -2080, 1429, 3266, 885, 886, -1957, -1295, -1315, -2075, -2075, - 983, -1314, 2713, -2098, -2098, -1312, -1312, -875, -870, 1692, - 3253, -875, 821, -1940, -1957, 1153, 1060, 2711, -1315, -837, - -850, 2717, 2718, 1364, 2727, 3471, 2656, 3270, 1060, -865, - 1770, 2134, 821, 819, 2937, 821, -878, 2704, 862, 821, - 2134, -2100, -2100, -480, 3200, -878, 3552, -1132, 1939, 1640, - 2173, 1765, 1159, 1941, 1642, -1132, 1829, 1348, 2174, 2523, - 982, 1196, 1438, 1616, 1263, 1830, 1939, 1713, -527, 23, - 1940, 1941, -531, 3347, 1348, 1689, 1060, 2940, 2764, 2766, - 2252, 2769, -1153, -229, 1650, 819, 819, 1008, -229, 1799, - -1153, 1790, 1802, 1803, 954, 3183, 881, 3360, 2478, 2479, - 2480, 538, 2803, 3431, 821, -665, 1640, 1199, 1339, 1039, - 1641, 1642, 2734, 1979, 1790, 71, 2347, 3236, 1652, 1059, - 3537, 1014, 1939, 1006, 1710, 1773, 1940, 1941, 2484, 2485, - -2102, -2102, -2102, 3577, 1157, 71, 1160, 2657, 809, 2491, - 3606, 1650, 2183, 2495, 3166, 1257, 3168, 1340, 3458, 3065, - 1979, 1378, 71, 1781, 2028, 1781, 2786, 2438, 2331, 1790, - 2882, 871, 2884, 3544, 1817, 3601, 2683, 3, 4, 881, - 1759, 1760, 1763, 3211, 2924, 1652, 2121, 1526, 2157, 2245, - 2467, 2651, 3495, 2214, 3390, 2883, 3267, 3039, 3590, 3197, - 809, 809, 887, 839, 3391, 3209, 3530, 1640, 1015, 1690, - 1640, 3268, 1611, 3290, 1589, 1488, 113, 3264, -807, 2585, - 2903, 3235, 26, 27, 28, 1875, 71, 3607, 535, 1813, - 1599, 2430, 3475, 876, 2953, 105, 3376, -2074, -2074, 1834, - 876, 2201, 1650, 992, 1044, 3350, 2468, 1578, 788, 46, - 2944, 3517, 1820, 1640, 3520, 1045, 2923, 1641, 1642, 1939, - 3173, 1021, 2458, 1940, 1941, 3261, 2202, 1489, -527, 3265, - 2775, 2906, -531, 3377, 3198, 1186, 1652, 1612, 2215, 1652, - 3210, 3260, 1318, 3559, 1154, 106, 3538, 2904, 1650, 33, - 3075, 3585, 3272, 1349, 879, 1775, 1711, 1823, 3174, 2945, - 114, 2834, 2184, 1192, 1220, 840, 2246, 1791, 2954, 3457, - 2439, 2648, 2158, 2648, 1161, 3539, 1162, 2946, 1607, 3608, - 2440, 789, 1652, 2277, 877, 3066, 38, 2652, 3378, 2159, - 1791, 877, 1833, 2332, 2160, 3215, 1341, 3379, 3602, -527, - -685, 3432, 1601, -531, 3212, 3358, 1468, 3583, 1016, 1258, - 2540, 3545, 1788, 3578, -807, 820, 3591, 3560, 1766, 40, - 1155, 3380, 3288, 3090, 1349, 880, 2253, 2658, 3547, 2659, - 43, 3392, 2161, 1054, 1788, 1791, 929, 1187, 865, 1194, - 2142, 1349, 2499, 1709, 3336, 2348, 3247, 3057, 3553, 2339, - 2469, 989, 2955, 863, 3201, 1761, 719, 1788, 1631, 2660, - 1702, 3054, 3269, 874, 3518, 2025, 2063, 1584, 1585, 2268, - 3348, 951, 2135, 1947, 1776, 2330, 955, 2092, 2947, 3069, - 3070, 2576, 1971, 2776, 2803, 46, -1132, 2948, 963, 2175, - 949, 3081, 1597, 1896, 3381, 3588, 2862, 3519, 1988, 1900, - 3579, 1762, 1788, 881, 3368, 2597, 2396, 3382, 1790, 2773, - 2705, 2706, 1342, 982, 893, 1350, 3017, 539, -527, 2010, - 3419, -1153, -531, 3040, 1815, 2623, 3019, 2239, 859, 3580, - 2543, 912, 2144, 2425, 3609, 913, 3613, 1368, 1369, -1949, - 1580, 2618, 2612, 2725, -1373, 2431, 2189, 2730, 1594, -1949, - -454, -454, 2074, 2075, 2818, 2402, 2719, -527, 1594, -527, - 3339, -531, -1314, -531, -1940, 3340, 1314, 1102, 1103, -371, - 1937, 1938, 1818, 1586, 2684, 2459, 1958, 912, -1957, -1295, - -1315, 913, 2464, 1602, -1314, 2709, 1353, 3359, 3191, 2162, - -875, -870, 1602, 3310, 1895, 1635, -1940, -1957, 1368, 1369, - 1904, -1315, 1587, 1592, 872, 1603, 1263, 2115, 1263, 976, - 2060, 1616, -865, 1897, 1603, 1685, 1002, 981, 2191, 1604, - 1616, 1956, 1673, 2496, 1724, 878, 3463, 2496, 1606, 1809, - 2659, 3250, 2518, 3439, 2095, 3464, 1953, 1954, 1955, 1956, - 77, 942, 3342, 1977, 978, 784, 3224, 3225, 2787, 2788, - 2789, 2790, 3456, 1810, 882, 872, 2517, 525, -229, -229, - 2966, 3352, 3217, 2891, 3182, 2116, 3505, 2330, 525, 1020, - 3222, 1163, 931, 541, 932, 525, 1670, 1671, 1672, 1673, - 943, 2927, 968, 2797, 2933, 1192, -2102, -2102, -2102, 523, - 1951, 1952, 1953, 1954, 1955, 1956, 3440, 1208, -1359, 3242, - 523, 3085, 888, 2465, 525, 525, 3452, 523, 3383, 889, - 2934, 3384, 817, 1895, 1791, 2721, 1906, 1158, 2892, 108, - 1589, 1060, 1602, 817, 71, 1301, 3046, 2273, 525, 2303, - 817, 3327, 1725, 3329, 3184, 1158, 542, 875, 2387, 2306, - 1599, 2677, 2309, 1004, 1603, 2465, 821, 57, 65, 82, - 103, 1476, 53, 1164, 2678, 68, 69, 1483, 3528, 1908, - 2419, 1194, 77, 890, 1060, 2420, 945, 99, 94, 2928, - 2804, 2302, 70, 3251, 2051, 525, 719, 3017, 1790, 1307, - 525, 1788, 1790, 3261, 1809, 3147, 1790, 3019, 2274, 2586, - 2359, 891, 1804, 1005, 3033, 2137, 3034, 1173, 3124, 908, - 869, 3126, 3506, 3128, 851, 851, 1721, 851, 1810, 851, - 1195, 1668, 1669, 1670, 1671, 1672, 1673, 1951, 1952, 1953, - 1954, 1955, 1956, 2472, 2421, 2326, 2327, 2328, 821, 50, - 51, 2265, 1307, 52, 55, 2929, 2360, 2930, 56, 2407, - 3425, 2395, 3426, 981, 910, 2397, 3372, 59, 2399, 60, - 525, 525, 61, 3403, 541, 2092, 525, 63, 2301, 525, - 525, 66, 525, 525, 525, 525, 3345, 67, 872, 3603, - 77, 80, 2853, 2145, 819, 784, 1360, 2412, 2312, 525, - 1317, 525, 81, 2319, 83, 819, 84, 90, 3507, 109, - 525, 91, 819, 93, 98, 102, -1949, 104, 2693, 1217, - 110, 2146, 1987, 3332, 2694, 1218, 2682, 525, 1307, 1572, - 2686, 523, 1962, 523, 2690, 541, 3477, 542, 546, 23, - 972, 2598, 523, 2599, 928, 1393, 1394, 1401, 1402, 525, - 2273, 2061, 1230, 1781, 817, 111, 817, 1805, 71, 871, - 2067, 916, 823, 549, 1782, 817, 550, 1806, 525, 2566, - 2304, 872, 1231, 2053, 810, 2307, 1004, 1815, 1781, 525, - 525, 525, 2621, 525, 525, 810, 719, 1060, 1631, 1784, - 912, 2698, -1295, 2629, 913, 3157, 2277, 2567, 542, 991, - 1192, 1621, 935, 1602, 1791, 1193, 112, -209, 1791, 1602, - 1003, 2645, 1791, 3491, 3492, 1401, 1402, 1019, 1232, 525, - 2618, 2145, 939, 3321, 1465, 1603, 1005, 2463, 3282, 3322, - 1219, 1603, 3435, 1595, 1596, 1480, 2147, 525, 525, 1604, - 2377, 2336, 2378, 2685, 1217, 1606, 2149, 912, 947, 2146, - 1218, 913, 909, 1715, 1716, 933, 1722, 934, 1158, 1473, - 889, 889, 887, 889, 912, 3532, 1407, 1408, 1627, 1316, - 2177, 1788, 952, 525, 2178, 1788, 1194, 525, 525, 1788, - 71, 982, 26, 27, 28, 953, -608, 525, 525, 525, - 957, -608, 525, 1620, 956, 2432, 2433, 2434, 2435, 2436, - 2437, 958, 2804, 2441, 2442, 2443, 2444, 2445, 2446, 2447, - 2448, 2449, 2450, 1572, 1233, 2521, 819, 2568, 819, 546, - 2735, 972, 2569, 1816, 1727, 1195, 2743, 819, 869, 2670, - 1639, 2672, 2813, 1640, 1407, 1408, 1362, 1641, 1642, 1363, - 959, -2102, -2102, -2102, 2240, 2241, 1727, 550, 1307, 33, - 2473, 969, 2474, 1639, 940, 1219, 1640, 1307, -660, -660, - 1641, 1642, -608, 1234, 2147, -664, -664, 3132, 1650, 2148, - 1728, -2071, -2071, 1235, 2149, 1651, 2475, 987, 2476, 1849, - 546, 1307, 972, -2072, -2072, 1236, 38, 1220, 71, 998, - 912, 1650, 1728, 2564, 1627, 1025, 2418, 1628, -2102, 2150, - 2422, 988, 1652, 2424, 1572, 2594, 1700, 989, 550, 1701, - 2151, -608, 1856, 1857, 1859, 1860, 990, 1237, 1850, 40, - 719, 809, 3086, 1003, 1481, 1652, 941, 993, 1486, 719, - 43, 1026, 809, 2798, 996, 1889, 1462, 2805, 1217, -2073, - -2073, 1469, 1470, 1471, 1218, 1009, 981, 1474, 2092, 2667, - 1222, 2669, 997, 3255, 1048, 1049, 1050, 1028, 1492, 1053, - 1729, 1901, 1496, 719, 1902, 999, 3599, 1579, 525, 77, - 2920, 1239, 2922, 978, 784, 2570, 1007, 2024, 1911, 1591, - 2025, 1970, 1223, 1972, 1973, 46, 2571, 1000, 917, 1730, - 2561, 2562, 1189, 3586, 1191, 3587, 1240, 2049, 2344, 1653, - 2050, 2345, 3562, 3015, 1852, 1001, 1618, 1898, 2632, 1899, - 2413, 1730, 1220, 2414, 918, 1242, 1654, 3574, 525, 525, - 2451, 1655, -2102, 2452, 525, 942, 525, 2150, 1002, 2716, - 1041, 525, 525, 525, 525, 2964, 3612, 1046, 2151, -2102, - 1147, 1148, 2957, 1150, -2102, 1152, 525, 525, 1052, 1219, - 1051, 1731, 1054, 1224, 1055, 525, 3032, 525, 523, 1658, - 525, 1151, 2921, 879, 943, 525, 2497, 525, 525, 2498, - 525, 1221, 3610, 1731, 525, 1222, 2500, 3611, -609, 2498, - 919, 817, -2102, -609, 2835, 2836, 1032, 523, 1167, 523, - 1174, 3042, 523, 887, 887, 2673, 887, 523, 2674, 944, - 523, 2956, 523, 2965, 1175, 1475, 523, 1223, 1181, 920, - 817, 1177, 817, 2679, 1661, 817, 2680, 1178, 2746, 2810, - 817, 2025, 2498, 817, 2811, 817, 1179, 2050, 1572, 817, - 810, 3549, 810, 2814, 880, 810, 2815, 1661, -2076, -2076, - 810, 1182, 3421, 810, 3422, 810, -2077, -2077, 2816, 810, - 945, 2815, 921, 1620, -609, -2078, -2078, 1190, 1616, 2898, - 525, 525, 2899, 2824, 2826, 2827, -2079, -2079, 2822, 525, - 525, 2052, 2823, 2825, 2054, 2055, 2821, 525, 1224, 1209, - 2001, 77, 2002, 1212, 525, 2004, 2059, 2058, 1214, 3055, - 2008, 2056, 2414, 2011, 3056, 2012, 1215, 2345, 1216, 2016, - 1228, 821, 3079, -609, 3087, 3080, 1220, 3088, -2081, -2081, - 719, 525, 881, 1229, 1301, 525, 1663, 3148, 525, 3283, - 2050, 1246, 2050, 1572, 525, 525, 525, 525, 525, 525, - 525, 525, 719, 1250, 1217, 1254, 525, 525, 525, -2102, - 1218, 525, 1255, 819, 1310, 525, 1313, 2131, 525, 525, - 525, 525, 525, 525, 525, 525, 525, 3284, 1321, 525, - 2498, 2756, -2082, -2082, 1314, 1247, 525, 71, 1307, 1222, - 523, 1319, 819, 1325, 819, 1335, 982, 819, 2186, 922, - 2618, 3316, 819, 1337, 2050, 819, 525, 819, 2221, 3323, - 923, 819, 2025, 1473, 3229, 889, -2083, -2083, 1338, 1217, - 116, 1248, 1345, 3333, 536, 1218, 3334, 2115, 1346, 525, - 3366, 1164, 749, 2414, 3367, 3400, 3461, 2345, 2050, 2414, - 525, 525, 14, 15, 1664, 924, 838, -2102, -2102, -2102, - 852, 1668, 1669, 1670, 1671, 1672, 1673, 3192, 1356, 3473, - 3499, 2964, 3474, 3500, 1352, 1219, 1355, -2102, 925, 541, - 3543, -663, -663, 3474, 1668, 1669, 1670, 1671, 1672, 1673, - 1572, 1361, 3584, 882, 1217, 3474, -2084, -2084, 23, 719, - 1218, 719, 1224, 1379, -1359, 1380, 926, 809, 1385, 809, - -2085, -2085, 809, 1443, 2289, 1456, 2293, 809, 2914, 1217, - 809, 2076, 809, -2086, -2086, 1218, 809, 1458, 2077, 2078, - 1459, 2028, 2079, 2080, 2081, -2087, -2087, 3246, -2088, -2088, - 1219, 525, 542, -540, 3038, 3067, 1307, -2090, -2090, 525, - 525, 3049, -2091, -2091, 3078, 985, 2269, 1466, -540, 1025, - 1477, 2866, 2867, -540, -2092, -2092, 2278, 1022, 2281, 1478, - 3561, 2292, 1023, 1484, 3563, -2093, -2093, 2296, 1485, 2298, - -2094, -2094, 1491, 3309, 1497, 3159, 1495, 1043, 1574, 3399, - 1307, 1575, 2305, -2095, -2095, 1026, 971, 2308, -2097, -2097, - 1577, 2313, 2314, 2315, 2316, 1219, 2320, 2321, 719, 71, - -841, 1482, 1149, -848, -540, 1307, 525, -2099, -2099, 1586, - 2381, 1028, -2101, -2101, 981, 1836, 1837, 1403, 1404, 3604, - 1219, 1024, 1220, 1590, -540, 1407, 1408, 3188, 3189, 46, - 1572, 26, 27, 28, 525, 525, -685, 525, 940, 2748, - 2750, -686, 1572, 525, 525, 525, 525, 525, 525, -838, - 823, 525, 525, 525, 525, 525, 525, 525, 525, 525, - 525, 2618, 3570, 3571, 545, -839, 525, 525, 3596, 3597, - 525, 1600, 1572, -540, 1696, 1697, -842, 525, 1601, 1572, - 2141, 1251, -540, 3015, -840, 1222, 1622, 1220, 2637, 2638, - 1632, 1634, 1679, 1025, 1681, 1695, 1683, 1703, 33, 1704, - 1712, 525, 1708, 1193, 1195, 1751, 525, 1714, 525, 35, - 941, 1749, 525, 1753, 546, 1768, 972, 1252, 1786, 1787, - 1572, 1793, 1788, 1795, 1572, 3220, 525, 1794, 1307, 1026, - 1572, 37, 3399, 548, 1800, 38, 1808, 1370, 523, 549, - 1032, 1807, 550, 1812, 523, 1027, 2264, 1413, 887, 3082, - 1222, 3364, 1220, 1572, 1987, 1028, 113, 3230, 3231, 1475, - 1822, 817, 1828, 1832, 1839, 525, 525, 817, 40, 1845, - 1840, 1841, 1854, 1855, 3399, 1848, 1863, 1220, 1864, 43, - 1867, 810, 1223, 1870, 1871, 1873, 1874, 810, 1224, 1029, - 3123, 1876, 1877, 1890, 1891, 2617, 44, 1903, 1895, 1928, - 1930, 1931, 1933, 525, 1936, 1959, 1967, 525, 1978, 1849, - 2005, 2310, 525, 525, 1968, 1222, 1975, 2003, 1998, 2000, - 45, 2009, 2013, 3399, 2023, 2014, 2015, 2020, 1620, 1580, - 872, 2486, 2063, -540, 46, 1030, 2317, 2489, 525, 525, - 1222, 2026, 1031, 525, 1587, 2032, 1060, 2311, 1850, 3454, - 1022, 1592, 2027, 1224, 2029, 1023, 2096, 2031, 2097, 525, - 2030, 1640, 525, 525, 525, 541, 2062, 1633, 3415, 2100, - 2107, 2109, 2318, 2104, 2112, 2110, 23, 1636, 2133, 2111, - 525, 719, 2154, 1851, 1032, 2153, 2362, 525, 2156, 2180, - 525, 2181, 2187, 2199, 2200, 523, 2204, 2220, 71, 1686, - 2217, 880, 912, 1033, 1230, 1177, 913, 525, 1691, 2229, - 2231, 2230, 2234, 2232, 1024, 3208, 2233, 2255, 1224, 1569, - 525, 3206, 523, 819, 1231, 2256, 2251, 2259, 542, 819, - 2380, 2266, 2271, 2270, 1852, 881, 2272, 525, 525, 523, - -540, 2342, 2352, 1224, 3015, 817, 2346, 2363, 2361, 2364, - 2365, 23, 2366, 2367, 525, -540, 525, 2368, 2383, 2382, - -540, 2385, 817, 2388, 2389, 810, 2390, 2391, 1059, 525, - 1232, 1939, 1034, 1898, 2394, 1940, 1941, 2006, 2392, 1942, - 1943, 1944, 810, 2398, 2415, 1939, 1025, 719, 719, 719, - 2423, 1964, 2453, 1963, 2460, 2461, 1815, 2482, 2490, 2502, - 2462, 544, 2289, 2289, 2289, 2466, 2470, 3353, 2082, 2083, - 2084, -540, 2085, 2086, 2087, 2088, 2089, 2090, 1561, 26, - 27, 28, 1026, 2504, 1693, 2471, 525, 2488, 809, 2509, - 2510, -540, 1307, 2532, 809, 2511, 2535, 2513, 1027, 2514, - 2960, 2515, 2516, 2520, 2519, 2530, 2527, 2528, 1028, 1373, - 2531, 872, 2533, 2534, 2536, 2547, 2537, 1612, 3281, 2543, - 1316, 2560, 1856, 1857, 1859, 1860, 1233, -208, 719, 2538, - 982, 2565, 2572, 1572, 2557, 2558, 2581, 2582, 2589, 2587, - -540, 2588, 1029, 1911, 2600, 2601, 33, 2605, 2606, -540, - 2603, 2611, 2613, 525, 26, 27, 28, 2625, 2627, -666, - 2614, 2624, 1631, 1569, 2628, 2631, 2636, 819, 525, 981, - 546, 2635, 547, 2641, 2644, 1234, 1766, 719, 2647, 2643, - 2639, 2666, 2668, 38, 819, 1235, 2681, 2687, 1030, 2688, - 2689, 2699, 1911, 2700, 2701, 1031, 1910, 1236, 550, 2702, - 2715, 2714, 2720, 2732, 2736, 2737, 2740, 2733, 2744, 2115, - 2753, 2763, 2771, 1594, 2739, 525, 40, 2774, 2777, 1945, - 2780, 33, 3404, 2794, 3406, 1618, 2795, 43, 2781, 1237, - 2782, 2783, 2806, 2807, 2820, 2812, 3414, 1032, 2831, 2860, - 2828, 2849, 1946, 2861, 44, 2141, 2838, 523, 2839, 1637, - 2850, 2858, 1059, 525, 1569, 1939, 1033, 2864, 38, 1940, - 1941, 2583, 1561, 1942, 1943, 1944, 2879, 2881, 45, 1572, - 817, 2907, 809, 2873, 3416, 1158, 3418, 2911, 3536, 2874, - 1373, 2905, 46, 1239, 2888, 2919, 525, 3497, 2932, 809, - 2885, 40, 525, 525, 872, 2909, 2876, 2925, 2926, 2952, - -540, 2968, 43, 3035, 3036, 3037, 3052, 525, 1240, 3041, - 3044, 1022, 1947, 3045, 3063, 3053, 1023, 3058, 3501, 44, - 3490, 3059, 3071, 525, 3072, 1034, 525, 1242, 525, 3076, - 2345, 3083, 872, 3084, 3115, 1572, 525, 3089, 3111, 525, - 525, 3262, 3109, 45, 525, 525, 3119, 3129, 3130, 3179, - 3133, 525, 3485, 1561, 3134, 3160, 3167, 46, 3172, 3170, - 1373, 3181, 23, 1373, 1373, 3185, 525, 3186, 3187, 912, - 3193, 3194, 3195, 913, 3199, 1024, 525, 3203, 2052, 3204, - 3205, 2054, 2055, 2913, 3213, 521, 532, 3216, 77, 3218, - 3219, 557, 3237, 2059, 2058, 3223, 525, 557, 2056, 3238, - -2070, 807, -2071, 822, 2897, 2937, 3240, 825, 557, 834, - -2072, 2938, 834, -2073, 3254, 854, 854, 3256, 3239, 854, - 3241, -2074, 557, 557, 2939, -2075, -2076, -2077, -2078, 3271, - 3273, 3243, 819, -2079, -2081, 3275, 3244, 719, -2082, -2083, - 3018, 719, -2084, 719, 3257, -2085, 871, 1025, 2940, -2086, - 2941, 3252, 2289, 807, 807, 525, 3020, 525, 2293, -2087, - -2088, -2090, -2091, -2092, -2093, -2094, 1946, -2095, -2096, -2097, - 2916, -2098, -2099, 2917, -2100, -2101, -1312, 3276, 1569, 854, - 3259, 3279, 3285, 1026, 3286, 3289, 854, 557, 854, 854, - 854, 1856, 1857, 1859, 1860, 3291, 3293, 1907, 1909, 1027, - 2969, 3074, 3297, 3299, 3300, 26, 27, 28, 3303, 1028, - 2192, 3304, 3047, 3305, 3525, 3022, 3023, 3024, 3025, 3026, - 3027, 3028, 3029, 3030, 3031, 1948, 1949, 1950, 3308, 1951, - 1952, 1953, 1954, 1955, 1956, 3311, 1947, 525, 2942, 3315, - 1572, 3068, 3312, 1029, 3331, 3335, 3330, 1217, 3341, 872, - 3355, 3338, 3356, 1218, 3343, -1311, 3363, 525, 525, 3365, - 3371, 1230, 525, 3373, 1206, 525, 3374, 3387, 3388, 3389, - 3401, 3402, 33, 1569, 3408, 3405, 3409, 1561, 3411, 3417, - 3423, 1231, 2261, 2263, 3443, 3212, 3447, 3449, 3450, 1030, - 3453, 3459, 525, 3466, 3467, 23, 1031, 3471, 3468, 3478, - 3476, 3483, 3480, 3163, 3487, 3489, 2943, 3484, 3488, 38, - 3496, 2944, 525, 3494, 3503, 3498, 3508, 3514, 525, 525, - 3515, 3516, 3521, 525, 1572, 3522, 3551, 1232, 525, 1618, - 1230, 525, 525, 3531, 3523, 3541, 525, 1307, 1032, 3533, - 525, 2322, 40, 3535, 525, 872, 914, 3554, 3556, 3552, - 1231, 525, 3575, 43, 3553, 2337, 2337, 1033, 1219, 3572, - 2945, 3589, 3594, 3600, 3605, 3614, 3615, 1618, 2297, 1180, - 44, 2664, 1561, 2971, 2967, 3430, 523, 2900, 2946, 3529, - 3493, 3598, 3226, 2400, 2755, 1156, 71, 3512, 3582, 3351, - 3550, 3557, 71, 3576, 45, 525, 1232, 3386, 1778, 817, - 2671, 2646, 3062, 525, 3548, 2936, 3555, 2642, 46, 3021, - 1569, 3546, 1893, 2747, 2710, 2749, 2760, 3280, 2912, 810, - 2630, 2068, 525, 1233, 3043, 1705, 1034, 3428, 1370, 2258, - 2785, 1572, 2616, 2098, 2417, 2099, 1853, 3534, 26, 27, - 28, 1745, 1463, 1746, 2626, 1464, 2226, 3479, 3407, 1948, - 1949, 1950, 2257, 1951, 1952, 1953, 1954, 1955, 1956, 1750, - 811, 2602, 2494, 2117, 2893, 3018, 3307, 2779, 2778, 1465, - 3118, 2809, 1234, 3207, 1430, 3357, 2508, 3228, 3482, 2947, - 1414, 1416, 1235, 2409, 2410, 3481, 2411, 1420, 2948, 2555, - 1421, 1422, 1233, 1423, 1236, 2833, 1424, 1425, 2524, 1426, - 71, 2619, 2579, 3142, 2556, 33, 1989, 719, 2577, 1561, - 2852, 3143, 3171, 2886, 3469, 1220, 986, 2340, 2501, 23, - 1905, 1211, 1911, 2901, 2195, 2691, 1237, 2197, 0, 71, - 0, 0, 0, 0, 0, 525, 3073, 0, 0, 0, - 0, 1234, 38, 981, 1824, 0, 525, 1572, 0, 872, - 0, 1235, 0, 0, 0, 0, 3263, 0, 0, 0, - 1569, 819, 525, 1236, 0, 0, 2238, 2238, 541, 0, - 0, 0, 1569, 0, 1238, 40, 0, 0, 1222, 0, - 1239, 0, 0, 0, 1618, 0, 43, 0, 0, 0, - 1572, 0, 0, -1359, 0, 1237, 525, 0, 0, 0, - 0, 0, 1569, 44, 0, 1240, 0, 0, 0, 1569, - 1241, 0, 0, 525, 525, 0, 0, 525, 854, 525, - 0, 0, 0, 854, 1242, 1059, 854, 45, 1939, 0, - 1373, 542, 1940, 1941, 557, 0, 1942, 1943, 1944, 0, - 1373, 46, 0, 1373, 525, 1059, 0, 0, 1939, 1239, - 1569, 2894, 1940, 1941, 1569, 0, 1942, 1943, 1944, 1561, - 1569, 0, 26, 27, 28, 0, 809, 0, 525, 0, - 0, 1561, 0, 2855, 1240, 0, 0, 0, 0, 0, - 871, 1224, 0, 1569, 0, 543, 0, 0, 0, 0, - 0, 0, 0, 1242, 0, 0, 0, 0, 0, 0, - 3018, 1561, 0, 0, 544, 0, 0, 0, 1561, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1059, 0, 719, 1939, 0, 0, 0, 1940, 1941, 33, - 0, 1942, 1943, 1944, 0, 0, 0, 1911, 0, 0, - 1373, 0, 525, 0, 0, 0, 0, 0, 2856, 1561, - 3354, 3369, 525, 1561, 525, 0, 525, 0, 0, 1561, - 525, 0, 525, 545, 525, 0, 38, 0, 0, 0, - -208, 0, 3361, 3362, 523, 0, 0, 0, 525, 0, - 0, 0, 1561, 525, 0, 525, 0, 0, 0, 0, - 0, 0, 0, 525, 0, 0, 3375, 817, 0, 40, - 0, 0, 0, 0, 0, 0, 719, 0, 2675, 0, - 43, 525, 0, 546, 0, 547, 2254, 0, 0, 0, - 0, 3436, 0, 0, 961, 557, 557, 44, 3427, 0, - 3429, 0, 548, 0, 0, 0, 0, 0, 549, 1946, - 0, 550, 0, 0, 71, 0, 0, 0, 0, 0, - 0, 45, 0, 0, 0, 0, 0, 0, 525, 1946, - 2707, 0, 0, 2512, 0, 2895, 984, 532, 525, 0, - 3462, 0, 521, 0, 854, 0, 0, 0, 2722, 0, - 525, 0, 0, 807, 1618, 0, 3465, 1011, 1011, 0, - 807, 0, 0, 1011, 1038, 525, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 834, 834, 834, 1947, - 0, 834, 0, 525, 0, 0, 0, 0, 0, 1106, - 1106, 834, 834, 1370, 834, 0, 834, 523, 0, 1947, - 0, 0, 0, 2761, 1946, 2762, 0, 525, 854, 2767, - 0, 2770, 0, 0, 557, 0, 0, 0, 0, 0, - 817, 0, 525, 0, 0, 0, 854, 0, 0, 819, - 11, 3018, 0, 719, 0, 0, 0, 0, 0, 523, - 854, 822, 0, 0, 0, 0, 0, 0, 3436, 0, - 0, 0, 0, 0, 0, 0, 525, 0, 14, 15, - 0, 0, 817, 0, 0, 0, 0, 0, 0, 1439, - 525, 525, 525, 1569, 1947, 854, 1312, 0, 0, 0, - 0, 0, 3558, 0, 0, 0, 0, 1323, 523, 0, - 2596, 854, 854, 854, 854, 0, 0, 525, 3542, 0, - 0, 0, 0, 0, 23, 0, 0, 1344, 3573, 71, - 0, 817, 0, 0, 1022, 0, 0, 0, 0, 1023, - 0, 0, 0, 2622, 2622, 0, 0, 0, 0, 0, - 3393, 0, 0, 0, 0, 0, 0, 0, 525, 1011, - 1038, 0, 854, 0, 0, 1437, 0, 0, 0, 0, - 0, 1011, 1011, 0, 0, 0, 0, 0, 557, 0, - 0, 0, 0, 0, 807, 0, 807, 0, 0, -1831, - 0, 0, 1561, 0, 0, 807, 0, 0, 1024, 0, - 0, 0, 819, 0, 0, 557, 71, 0, 71, 0, - 0, 0, 1948, 1949, 1950, 0, 1951, 1952, 1953, 1954, - 1955, 1956, 1576, 0, 0, 0, 0, 0, 0, 1569, - 0, 0, 1948, 1949, 1950, 0, 1951, 1952, 1953, 1954, - 1955, 1956, 0, 0, 819, 0, 0, 0, 71, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1563, 0, 0, 71, 0, 1564, 26, 27, 28, - 1025, 0, 0, 557, 0, 0, 0, 0, 1203, 0, - 0, 0, 0, 0, 3011, 0, 0, 1742, 0, -1831, - 0, 0, 0, 819, 0, 1569, 1439, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1026, 1948, 1949, 1950, - 0, 1951, 1952, 1953, 1954, 1955, 1956, 2707, 0, 0, - 0, 0, 1027, 0, 0, 0, 1699, 0, 1561, 0, - 0, 1914, 1028, 0, 33, 0, -1831, 0, 1566, 0, - 0, 0, 557, 557, 0, 35, 0, 0, 0, 854, - 0, -1831, 0, 0, 0, 0, -1831, 0, 0, 0, - 0, -1831, 0, 0, 0, 0, 1029, 37, 0, 0, - -1831, 38, 1437, 1106, 1106, -1831, 0, 0, 1915, 0, - 0, 0, 0, 0, 854, 1777, 0, 1204, 0, 0, - 71, 39, 0, 0, 1561, 0, 0, 854, 1059, 1916, - 1569, 1939, 0, 0, 40, 1940, 1941, -1831, 0, 1942, - 1943, 1944, 1030, 0, 854, 43, 71, 1917, 854, 1031, - 0, 1918, 0, 1825, 0, 0, 3150, -1831, 0, 2817, - 2819, 0, 44, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1919, 1563, 0, 1920, 0, 0, - 1564, 0, 0, 0, 0, 0, 45, 0, -1833, 1567, - 0, 1032, 0, 1921, 0, 0, 0, 0, 0, 0, - 46, 0, 1568, 0, 0, 0, -1831, 0, 0, -1831, - 1033, 0, 1842, 0, 854, -1831, 0, 0, 0, 0, - 0, 0, 3169, 854, 0, 0, 0, 0, 0, 1561, - 1569, 853, 0, 0, 1886, 861, 0, 0, 0, 0, - 0, 0, 0, 961, 0, 0, 0, 0, 961, 0, - 557, 557, 1566, 557, 961, -1831, 0, 1439, 1439, 0, - 0, 0, 0, 1439, 0, 0, 1563, 0, 0, 0, - 0, 1564, 0, 0, 0, 0, 0, 0, 0, 1034, - -1831, 0, 0, 0, 1205, 0, 1922, 0, -1833, 0, - 0, 0, 0, 0, 1923, 897, 0, 0, 0, 0, - 0, 0, 900, 0, 903, 0, 907, 0, 0, 0, - 0, 0, 0, 0, 1569, 0, 1924, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1373, 0, 0, 1561, - 0, 0, 0, 1437, 1437, -1833, 0, 0, 859, 1437, - 0, 521, 1946, 1566, 0, 1925, 0, 0, 0, 0, - -1833, 0, 0, 0, 1011, -1833, 557, 1982, 0, 0, - -1833, 1106, 1106, 0, 854, 0, -1831, 0, 0, -1833, - 807, 0, 807, 1567, -1833, 807, -1831, 0, 0, 0, - 807, 0, 1106, 807, 0, 807, 1568, 0, 0, 807, - 3258, 557, 0, 557, 0, 0, -1831, 0, -1831, -1831, - 0, 0, 0, 0, 0, 0, -1833, 0, 0, 0, - 558, 0, 1947, 1561, 0, 0, 558, 1370, 0, 0, - 808, 1569, 0, 0, 0, 0, -1833, 558, 0, 0, - 0, 0, 0, 0, 0, -1831, 0, 0, -1831, -1831, - -1831, 558, 558, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1569, 0, 0, 0, 0, - 0, 3125, 0, 0, 1567, 0, 0, 0, 0, 0, - 0, 0, 808, 808, 0, -1833, 0, 1568, -1833, 0, - 0, 0, 0, 0, -1833, 0, 0, 0, 0, 0, - 1563, 0, 0, 0, 0, 1564, 0, 0, 2091, 0, - 0, 0, 0, 0, 3328, 0, 558, 0, 0, 0, - 557, 0, 0, 0, 1059, 0, 0, 1939, 0, 0, - 1561, 1940, 1941, 0, -1833, 1942, 1943, 1944, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1569, 0, 0, - 0, 0, 3151, 0, 0, 0, 0, 0, 2228, -1833, - 961, 0, 0, 1437, 1561, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1566, 0, 0, - 0, 0, 0, 0, 3011, 0, 0, 0, 0, 0, - 1569, 1106, 0, 0, 0, 1563, 0, 0, 0, 0, - 1564, 0, 0, 0, 0, 0, 2193, 0, 854, 0, - 854, 0, 0, 0, 0, 0, 1373, 859, 0, 0, - 854, 1373, 2209, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1437, 1948, 1949, 1950, 0, 1951, - 1952, 1953, 1954, 1955, 1956, -1833, 1561, 0, 0, 0, - 0, 0, 0, 0, 0, -1833, 0, -1848, 0, 854, - 0, 557, 0, 0, 0, 0, 0, 0, 1907, 1909, - 0, 0, 1566, 2260, 2262, -1833, 0, -1833, -1833, 1777, - 557, 0, 0, 0, 0, 0, 0, 0, 0, 1561, - 557, 2279, 557, 2283, 0, 557, 0, 0, 1567, 0, - 1569, 557, 0, 557, 0, 0, 0, 0, 0, 0, - 0, 1568, 3455, 0, -1833, 961, 557, -1833, -1833, -1833, - 961, 557, 0, 0, 0, 557, 557, 557, 557, 0, - 557, 557, 1563, 0, 0, 0, 0, 1564, 1946, 0, - 0, 0, 0, 0, 930, 0, 0, 0, 2341, 937, - 0, 0, 938, 0, 0, 0, 1323, -1848, 854, 854, - 854, 854, 854, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1439, 1439, 1439, 1439, 1439, 1439, 0, 2370, + 525, 914, 872, 53, 57, 65, 82, 103, 68, 719, + 69, 94, 1140, 1207, 77, 963, 525, 99, 884, 1244, + 1036, 1964, 1315, 523, 1263, 1445, 858, 70, 1826, 1989, + 1814, 1501, 1798, 1354, 77, 982, 1318, 784, 2221, 523, + 718, 1779, 1815, 2188, 1607, 522, 1707, 2623, 778, 1417, + 2024, 2327, 1415, 2105, 2336, 1864, 1172, 2144, 2055, 888, + 2658, 817, 1418, 1371, 856, 1831, 2094, 1789, 525, 525, + 2506, 1360, 2727, 810, 1764, 1419, 2613, 1377, 50, 889, + 745, 1785, 51, 3049, 52, 2596, 55, 2598, 2121, 2122, + 56, 523, 523, 59, 60, 3018, 61, 1684, 1896, 905, + 63, 66, 1687, 870, 67, 2651, 1243, 80, 1249, 1819, + 1253, 3047, 81, 817, 817, 3020, 83, 851, 1263, 2577, + 3065, 2612, 976, 973, 965, 810, 810, 1620, 898, 1014, + 84, 3062, 90, 91, 2843, 1039, 2710, 93, 98, -1949, + 2192, 102, 104, 885, 886, 2911, 2358, -2089, -2089, 2916, + 2354, -1373, -1949, 2508, 1060, -454, 2241, -1314, 1060, -527, + 2460, 1982, 2244, 1584, 1585, 3137, 1983, 1061, 1348, -371, + -870, 3267, -875, 537, -531, -1940, -875, 983, 2714, 1384, + 1597, 2136, 1348, -1295, 2718, 2719, 2712, -1957, 3472, 1770, + 821, -1314, 2659, -1315, 1060, -837, 1429, 2353, 2728, -1311, + -1311, 2526, -878, -850, 1440, -1940, -865, -1957, 2136, -1315, + 821, 821, -878, -2080, -2080, -2098, -2098, -1312, -1312, 2146, + 862, 1688, 1364, 821, 3553, -2075, -2075, 1060, -2100, -2100, + 1364, 954, 1781, 819, 1692, 1060, 3201, -229, 1781, 1159, + 3254, 1941, -229, 1817, 1196, 879, 1943, 1569, 1153, 2686, + 876, 1829, 2765, 2767, -1132, 2770, 1199, 3271, 1339, -527, + 1830, 982, -1132, 1640, 2487, 2488, 3607, 1263, 1642, 3361, + 3348, 3140, 3578, 1160, -531, 2494, 1713, 1348, -480, 2498, + 876, 2350, 2735, 3184, 1773, 819, 819, 1008, 1941, 2804, + 538, 1616, 1942, 1943, 1765, 881, 3237, 1340, 1650, 1589, + 821, 3066, 3506, 2660, 3, 4, 2159, 3167, 3432, 3169, + -665, 1039, 1790, 1006, 1799, 1599, 880, 1802, 1803, 2883, + 3602, 2885, 1257, 1014, 3538, 2481, 2482, 2483, 3040, 1981, + 821, 2441, 1652, 881, 1157, 1689, 1790, 1710, 2175, 1832, + 3459, 877, 3212, 3608, 1640, 2254, 2176, 2030, 1641, 1642, + 3545, 1804, 1693, 1378, 3391, 2705, 2654, 821, 2185, 3591, + 1015, 2470, 3291, 3476, 3392, 3328, 1981, 3330, 942, -807, + 2787, 877, 3496, 2216, 2123, 1192, 1759, 1760, 2247, 1650, + -2074, -2074, 2925, -1153, 3531, 2928, 1724, 113, 1611, 839, + 1602, -1153, 2954, 2275, 881, 3268, 3426, 1809, 3427, 1186, + 1763, 1640, 2588, 1602, 3589, 3440, 3198, 943, 1044, 1488, + 3269, 1440, 1603, 1652, 992, 2433, 1781, 2471, 3236, 1045, + 2662, 1810, 3210, 3261, 1877, 1603, 1604, 1782, 1836, 2924, + 2160, 1569, 1021, 3518, 3273, 3609, 3521, 1526, 3507, 1606, + 1813, 1161, 2722, 1162, 1775, 3614, 2461, 2161, 2907, -527, + 2967, 1194, 2162, 1612, 2276, 3262, 3377, 2147, 2217, 1690, + 1220, 1489, 1318, 3560, -531, 1349, 2955, 3067, 3441, 3586, + 1652, 114, 3478, 2929, 2442, 2651, 1341, 2651, 3458, 1349, + 3539, 3199, 3579, 3603, 2443, 2148, 3076, 3404, 3561, -685, + 2163, 840, 2655, 945, 1725, 2248, 1805, 3211, 2835, 1711, + 1016, 1187, 1607, 3213, 1833, -807, 1806, 1154, 2186, 3540, + 3091, 2279, 1788, 3216, 3359, 3289, 1258, 3592, 1791, 2680, + -527, 1835, 1569, 2661, 3508, 2662, 1468, 1476, 3546, 3584, + 3548, 3393, 2681, 1483, 989, -531, 3433, 1601, 2065, 2930, + 2351, 2931, 1791, 955, 2543, 882, 2698, 2699, 2700, 1640, + 2956, 3058, 2137, 1641, 1642, 2663, 3554, 541, 3055, 2027, + 1709, 2472, 3337, 1776, 2144, 863, 929, 1702, 1761, 3580, + 3070, 3071, 559, 3519, 1349, 2342, 3202, 2502, 750, 2579, + 1762, 1818, 878, 1155, 1650, 1788, 719, 2687, 1631, 826, + 3610, 1766, 1342, 3082, 3041, 2270, 1054, 3349, 3581, 2804, + 2149, 3270, 2335, 869, 869, 2339, 1584, 1585, 3360, 1788, + 2151, 3248, 2521, 1602, 963, 1897, 2863, 951, 1652, 1898, + 542, 2255, 2094, -1132, 912, 1902, 2774, 1350, 913, 535, + 3420, 1597, 1580, 1941, 1990, 1603, 539, 1942, 1943, -527, + 1973, 1353, 1440, 1440, 982, 2241, 2600, 2164, 1440, 2399, + 2626, 3369, -1949, 3018, -531, 2012, 788, 3520, 3225, 3226, + 2776, 1594, 2819, 2428, 2731, -1949, 2726, 2615, 901, 1815, + -1314, 2191, -1373, 3020, 1594, 2434, -454, -454, -527, 1602, + -527, 1102, 1103, -870, 2405, -875, 2621, 1314, -1940, 1602, + -371, 2076, 2077, -531, 912, -531, -1295, 3340, 913, 3192, + -1957, 1603, 3341, 1635, -1314, 2462, -1315, 2177, 1587, 2720, + 872, 1603, 2467, 1809, 2710, 1604, 1592, 2904, -1940, -865, + -1957, 3311, -1315, 1685, 2193, 1606, 2146, 1368, 1369, 1899, + 1586, 976, 1906, 1002, 3457, 1368, 1369, 1810, 1163, 1263, + 2117, 1263, -229, -229, 1958, 1589, 1569, 981, 1640, 3251, + 2798, 2546, -1153, 2499, 2934, 2275, 3465, 2499, 2706, 2707, + 3343, 872, 1192, 2152, 789, 1599, 1673, 77, 2062, 1616, + 784, 2892, 2422, 3464, 2153, 1979, 1727, 2423, 1616, 3353, + 2935, 105, 978, 1650, 2905, 3265, 2520, 525, 1955, 1956, + 1957, 1958, 2097, 1972, 2335, 1974, 1975, 2569, 525, 2053, + 1020, 1438, 546, 1851, 972, 525, 2788, 2789, 2790, 2791, + 523, 3183, 1217, 2777, 1217, 2884, 2648, 1652, 1218, 3086, + 1218, 523, 1728, 2118, 1192, 2570, 2893, 820, 523, 1193, + 550, 106, 817, 1208, 525, 525, 2424, 3266, 1194, 888, + 3529, 1569, 1852, 817, 1670, 1671, 1672, 1673, 1158, 2203, + 817, 2468, 3492, 3493, 3218, 1004, 3047, 3453, 525, 889, + 1781, 1301, 3223, -608, 1897, 2390, 1158, 2063, -608, 3185, + 3174, 1784, 859, 1005, 2204, 3252, 2069, 3256, 53, 57, + 65, 82, 103, 68, 2305, 69, 94, 1195, 2187, 77, + 1729, 1164, 99, 2468, 2308, 2805, 1362, 2311, 1727, 1363, + 1194, 865, 70, 3148, 3533, 525, 719, 821, 3175, 1307, + 525, 2696, 2304, 3262, 3018, 912, 1217, 2697, 3034, 913, + 3035, 2139, 1218, 1219, 1173, 1219, 851, 851, 1854, 851, + 3322, 851, 2589, 1440, 3020, 3125, 3323, 1908, 3127, -608, + 3129, 1730, 1060, 1910, 1728, 2571, 874, 2475, 1060, 1195, + 2572, 3604, 875, 50, 2328, 2329, 2330, 51, 2363, 52, + 890, 55, 1307, 2398, 3373, 56, 891, 2400, 59, 60, + 2402, 61, 2267, 981, 872, 63, 66, 3346, 1569, 67, + 525, 525, 80, 1790, -2071, -2071, 525, 81, -608, 525, + 525, 83, 525, 525, 525, 525, 2410, 77, 1317, 2303, + 784, 2094, 908, 1731, 819, 84, 1360, 90, 91, 525, + 2415, 525, 93, 98, 2854, 819, 102, 104, 2624, 2314, + 525, 893, 819, 1060, 2321, 821, 108, 1219, 14, 15, + -1949, 912, 523, 1964, 523, 1627, 2179, 525, 1307, 1572, + 2180, 1481, 3333, 523, 1989, 1486, 910, 1668, 1669, 1670, + 1671, 1672, 1673, 916, 817, 1700, 817, 872, 1701, 525, + 2601, 1903, 2602, 1730, 1904, 817, 810, 1790, 1004, 928, + 1147, 1148, 1473, 1150, 23, 1152, 2306, 810, 525, 935, + 1220, 2309, 1220, 912, 1465, -1295, 1005, 913, 2055, 525, + 525, 525, -209, 525, 525, 1480, 719, 3158, 1631, 1595, + 1596, 2701, 1815, 2573, 947, 2026, 912, 2279, 2027, 939, + 1627, 1820, 2938, 1628, 2574, 949, 2147, 1048, 1049, 1050, + 952, 2632, 1053, 3436, 953, 1731, 3283, 1621, 956, 525, + 1569, 1953, 1954, 1955, 1956, 1957, 1958, 1790, 931, 1221, + 932, 1247, 1569, 1222, 2148, 1222, 2621, 525, 525, 1440, + 1440, 1440, 1440, 1440, 1440, 2941, 957, 1440, 1440, 1440, + 1440, 1440, 1440, 1440, 1440, 1440, 1440, 2466, 958, 1158, + 1715, 1716, 1569, 1722, 2688, 1223, 933, 1248, 934, 1569, + 989, 1393, 1394, 525, 1220, 959, 3378, 525, 525, 1791, + 889, 889, 969, 889, 982, 1823, 109, 525, 525, 525, + 541, 1790, 525, 1790, 998, 2805, 2051, 110, 1025, 2052, + 1007, 2347, 1620, 940, 2348, -2072, -2072, 26, 27, 28, + 1569, -2073, -2073, 1572, 1569, 2736, 819, 1009, 819, 2421, + 1569, 2744, 2416, 2425, 1816, 2417, 2427, 819, 987, 1939, + 1940, 3379, 111, 2814, 1026, 1960, 1224, 1222, 1224, 988, + 3380, 1401, 1402, 1569, 990, 2524, 1788, 3243, 1307, 2149, + 1474, -2076, -2076, 542, 2150, 2685, 1217, 1307, 2454, 2151, + 1028, 2455, 1218, 1791, 3381, 2500, -2077, -2077, 2501, 1223, + 3133, 1217, -2078, -2078, 33, 941, 1217, 1218, 1578, 993, + 46, 1307, 1218, 112, 996, 35, 2503, 1059, 2676, 2501, + 1941, 2677, 1041, 2682, 1942, 1943, 2683, 968, 1944, 1945, + 1946, 1052, 2747, 3351, 1572, 2027, 2597, 37, 2945, 2811, + 997, 38, 2501, 823, 1858, 1859, 1861, 1862, 999, 2689, + 719, 2693, 1000, 2567, 1401, 1402, 3087, 1051, 2812, 719, + 1788, 2052, 1001, 1791, 1440, 1440, 2380, 3382, 2381, 1721, + 1224, 2670, 2815, 2672, 40, 2816, 981, 3600, 1217, 1002, + 3383, 1891, 2799, 1046, 1218, 43, 2806, 2946, -2079, -2079, + 1407, 1408, 2094, 719, -2081, -2081, 77, 1219, 525, 784, + 2817, 879, 44, 2816, 942, 2947, 2899, 1055, 3587, 2900, + 3588, 978, 1219, -2082, -2082, 1316, -609, 1219, 1054, 1032, + 3056, -609, 3057, 2417, 1913, 2348, 45, 1791, 3080, 1791, + 1788, 3081, 3088, 909, 3016, 3089, 3149, 1151, 1475, 2052, + 46, 1167, 2152, 943, 3563, 869, 2635, 3284, 525, 525, + 2052, 3613, 3285, 2153, 525, 2501, 525, 3317, 1175, 3575, + 2052, 525, 525, 525, 525, 546, 3324, 972, 1174, 2027, + 2958, 2717, 880, 1407, 1408, 1177, 525, 525, 944, 523, + 1440, 2965, 23, -2083, -2083, 525, 3033, 525, 1178, 1219, + 525, 2922, -609, 550, 1788, 525, 1788, 525, 525, 3334, + 525, 817, 3335, 2476, 525, 2477, 2948, 2478, 523, 2479, + 523, 2836, 2837, 523, 3611, 2949, 1179, 3043, 523, 3612, + 1181, 523, 3367, 523, 1182, 2417, 2957, 523, 2966, 945, + 817, 1948, 817, 3368, 3401, 817, 2348, 2052, -2084, -2084, + 817, -609, 810, 817, 810, 817, 1190, 810, 3462, 817, + 881, 2417, 810, 1209, 1220, 810, 1212, 810, 1572, 1473, + 2003, 810, 2004, 1214, 3422, 2006, 3423, 1215, 3474, 1220, + 2010, 3475, 1216, 2013, 1220, 2014, 2673, 1228, 2675, 2018, + 3500, 3384, 3544, 3501, 3385, 3475, 3585, -2085, -2085, 3475, + 525, 525, 1255, 1620, 1569, 1229, 2823, 2054, 2822, 525, + 525, 1949, 2056, 1246, 2057, 2060, 1250, 525, 77, 2824, + 2826, 2061, 1254, 1251, 525, 1310, 940, 1222, 2921, 1616, + 2923, 2058, 2825, 2827, 2828, 26, 27, 28, 2266, -2086, + -2086, 1059, 1222, 2312, 1941, -2087, -2087, 1222, 1942, 1943, + 719, 525, -2102, -2102, -2102, 525, 1220, 1313, 525, 1252, + 1301, -2088, -2088, 1572, 525, 525, 525, 525, 525, 525, + 525, 525, 719, 1189, 1223, 1191, 525, 525, 525, 2313, + 1314, 525, 1319, 819, 1321, 525, -2090, -2090, 525, 525, + 525, 525, 525, 525, 525, 525, 525, 1325, 941, 525, + 2757, 523, 33, 2133, 1335, 1025, 525, 1337, 1307, -2091, + -2091, 882, 819, 1338, 819, 2319, 1345, 819, 1346, 1222, + 982, 2188, 819, -2092, -2092, 819, 525, 819, 1561, 1352, + 1224, 819, -540, 3230, 2621, 2223, -2093, -2093, 541, 38, + 1569, 1026, -2094, -2094, 1355, 1224, 1356, -540, 1361, 525, + 1224, 2320, -540, 2117, 1379, 889, 1456, 1482, 1380, 1164, + 525, 525, 1385, 869, -2095, -2095, 1443, 1028, -2097, -2097, + -2099, -2099, 40, 1458, 3193, 1459, 2435, 2436, 2437, 2438, + 2439, 2440, 1478, 43, 2444, 2445, 2446, 2447, 2448, 2449, + 2450, 2451, 2452, 2453, 1477, 2965, 1466, 1851, -2101, -2101, + 1572, 542, 1484, -540, 1838, 1839, 1569, 2242, 2243, 719, + 1495, 719, -660, -660, -664, -664, 1440, 1440, -663, -663, + 1403, 1404, 1224, -540, 1950, 1951, 1952, 1485, 1953, 1954, + 1955, 1956, 1957, 1958, 1491, 2030, 1852, 2915, 46, 1497, + 2291, 1462, 2295, 1407, 1408, 3247, 1469, 1470, 1471, 3189, + 3190, 525, 3050, 1230, 1574, 3079, 3039, 1575, 1307, 2749, + 2751, 525, 525, 1492, 116, 3068, 1577, 1496, 536, 3597, + 3598, 1853, -540, 1231, 544, 3562, 749, 3571, 3572, 3564, + -841, -540, 1696, 1697, 2640, 2641, -848, 1586, 3400, 46, + 838, 3160, 3310, 1590, 852, -685, 1032, -686, -838, -839, + 1600, -842, 1307, -840, 1601, 1679, 1622, 1632, 1634, 1681, + 1683, 1569, 1561, 1695, 1703, 1475, 1704, 1708, 1712, 1232, + 719, 1193, 1854, 1714, 1195, 1949, 1749, 1307, 525, 1753, + 1751, 1768, 2384, 1316, 3605, 1786, 981, 1787, 1788, 1793, + -208, 1794, 1900, 1795, 1901, 1800, 1807, 1808, 1812, 1822, + 113, 1828, 1572, 1841, 1842, 1843, 525, 525, 1847, 525, + 1850, 1857, 1856, 1865, 1572, 525, 525, 525, 525, 525, + 525, 2564, 2565, 525, 525, 525, 525, 525, 525, 525, + 525, 525, 525, 546, 1869, 547, 1866, 1872, 525, 525, + 1873, 1875, 525, 1876, 1572, 2621, 1878, 1879, 917, 525, + 1892, 1572, 3016, 1561, 1893, 1897, 1905, 1930, -1831, 1569, + 1932, 550, 1440, 1933, 1935, 1233, 1969, 1938, 1961, 1970, + 1977, 1980, 2000, 525, 918, 2005, 2002, 2011, 525, 2015, + 525, 2016, -540, 2017, 525, 2022, 2025, 1440, 1580, 2028, + 1587, 3400, 1572, 1592, 2029, 2031, 1572, 1217, 525, 2032, + 1307, 523, 1572, 1218, 2034, 2064, 2033, 523, 2065, 1060, + 2098, 1230, 1640, 2099, 1234, 2102, 2106, 3365, 3231, 3232, + 2109, 3221, 2111, 817, 1235, 1572, 2114, 2112, 2113, 817, + 2135, 1231, 2182, 3400, 1989, 810, 1236, 525, 525, 2158, + 919, 810, 2155, 1569, 2183, 2189, 2156, 2201, 2202, 2206, + 880, 912, 2222, 2489, 1177, 913, 2231, 3124, -1831, 2492, + 2219, 2232, 2233, 2236, 2234, 2253, 985, 2235, 1237, 920, + 2257, 2268, 2258, 2261, 2273, 525, 2272, 1232, 872, 525, + 2274, 881, 3400, 2331, 525, 525, 2332, 2333, -2102, -2102, + -2102, 2345, 1953, 1954, 1955, 1956, 1957, 1958, 1043, 2355, + 2349, 2366, 2367, 2364, 2368, -1831, 1620, 2369, 1219, 2370, + 525, 525, 921, 2371, 2385, 525, 1022, 3455, 2388, 2386, + -1831, 1023, 1239, 1149, 2391, -1831, 2392, 2393, 1440, 2394, + -1831, 525, 2395, 2397, 525, 525, 525, 1439, 2418, -1831, + 2401, 2426, 1966, 1941, -1831, 2456, 1965, 1240, 2485, 2463, + 1569, 2473, 525, 719, 2464, 3416, 2465, 2493, 523, 525, + 2469, 2474, 525, 2505, 2507, 2491, 1242, 2512, 2513, 2514, + 2516, 823, 2523, 1233, 2517, 2518, -1831, 1561, 2519, 525, + 1024, 2550, 2522, 2538, 1569, 523, 2530, 2533, 3207, 2531, + 2539, 1230, 525, 2536, 2534, 819, -1831, 2535, 2546, 2537, + 1612, 819, 523, 2540, 2541, 2560, 2561, 817, 2568, 525, + 525, 1231, 2563, 3016, 2575, 2584, 2585, 2592, 2590, 810, + 2591, 2604, 1234, 2603, 817, 2606, 525, 2608, 525, 2609, + 2614, 2616, 1235, 2617, 2628, -666, 810, 2627, 2630, 922, + 2631, 525, 2634, 2638, 1236, -1831, 2639, 1766, -1831, 2642, + 923, 2644, 1025, 541, -1831, 2647, 2646, 1232, 1370, 719, + 719, 719, 2650, 2669, 2671, 1220, 1569, 2703, 1413, 2684, + 2690, 1440, 1561, 2716, 2702, 2721, 1237, 2733, -1359, 2715, + 1815, 2737, 3550, 2741, 2738, 924, 2691, 3354, 1026, 2692, + 2291, 2291, 2291, 2745, -1831, 2734, 2754, 1594, 525, 2764, + 872, 2775, 2772, 2795, 1027, 2778, 2781, 1307, 925, 1569, + 2796, 2271, 2782, 2783, 1028, 2807, 542, 2808, 2813, -1831, + 2832, 2280, 2839, 2283, 1238, 2784, 2294, 2961, 1222, 2821, + 1239, 2851, 2298, 2829, 2300, 1742, 926, 1858, 1859, 1861, + 1862, 719, 982, 2840, 1439, 2850, 1572, 2307, 1029, 2859, + 2861, 2862, 2310, 1233, 2865, 1240, 2315, 2316, 2317, 2318, + 1241, 2322, 2323, 2867, 2868, 2880, 525, 2889, 2874, 1206, + 543, 2908, 1913, 1631, 1242, 2875, 2912, 859, 2882, 819, + 2886, 525, 981, 2906, 2920, 2926, 2910, 2927, 1633, 544, + 719, 2953, 2933, 2969, 1030, 3036, 819, 3037, 1636, 3038, + 3045, 1031, 1234, 3042, 3046, -1831, 3053, 3054, 3059, 1561, + 3060, 3064, 1235, 3072, 3073, -1831, 3077, 2348, 3084, 1569, + 1686, 1913, 3085, 2117, 1236, 3090, 3110, 3112, 525, 1691, + 3116, 1224, 3120, 3130, 3131, -1831, 3134, -1831, -1831, 3180, + 3135, 3161, 3168, 1032, 3171, 3173, 3182, 3186, 545, 3187, + 3188, 523, 3194, 3415, 3195, -208, 1237, 1059, 3196, 3200, + 1941, 3405, 1033, 3407, 1942, 1943, 525, 3204, 1944, 1945, + 1946, 3205, 3206, 817, -1831, 3214, 3219, -1831, -1831, -1831, + 3217, 3220, 1572, 872, 3224, 3239, 3240, 1440, -2070, 1158, + 3417, 3244, 3419, 3238, -2071, -2072, 3537, -2073, 546, 525, + 547, -2074, 3241, -2075, -2076, 525, 525, 3498, -2077, -2078, + 1239, -2079, -2081, 3255, 3242, 2877, 3257, 548, -2082, -2083, + 525, 872, -2084, 549, -2085, -2086, 550, -2087, -2088, -2090, + 3491, 1034, -2091, -2092, -2093, 1240, 525, -2094, -2095, 525, + 3502, 525, -2096, -2097, -2098, -2099, -2100, -2101, 1572, 525, + -1312, 3245, 525, 525, 1242, 3272, 3253, 525, 525, 3083, + 3258, 1561, 3260, 3274, 525, 3277, 3276, 3280, 3286, 3486, + 1563, 3287, 2914, 1561, 3290, 1439, 1439, 3304, 3292, 525, + 3294, 1439, 3306, 3298, 3301, 3300, 3305, 2054, 3309, 525, + 3312, 3313, 2056, 3316, 2057, 2060, 521, 532, 77, 1022, + 3331, 2061, 557, 1561, 1023, 3332, 3336, 3339, 557, 525, + 1561, 2058, 807, 3342, 822, 3344, 3356, 2898, 825, 557, + 834, 3357, 2894, 834, -1311, 3364, 854, 854, 3366, 3372, + 854, 3374, 3375, 557, 557, 3402, 23, 3388, 3389, 3403, + 3390, 3406, 3409, 3412, 3410, 819, 3418, 3424, 1947, 3444, + 719, 1561, 3213, 3019, 719, 1561, 719, 1912, 3448, 3450, + 3451, 1561, 3454, 1024, 807, 807, 541, 3467, 525, 3468, + 525, 1948, 3460, 2938, 3472, 3469, 3477, 23, 3479, 2939, + 1569, 2291, 3481, 3164, 1561, 3021, 3484, 2295, 3075, 3488, + 854, -1359, 2940, 3485, 3490, 3499, 3489, 854, 557, 854, + 854, 854, 3495, 3497, 1858, 1859, 1861, 1862, 3504, 3509, + 3516, 3517, 3515, 3522, 3523, 3524, 2941, 3532, 2942, 3534, + 3542, 3526, 3552, 3048, 3536, 3209, 3555, 3557, 3573, 542, + 3576, 3554, 3553, 1373, 3590, 1025, 872, 3601, 3595, 3606, + 1900, 1949, -540, 1203, 3616, 3615, 1180, 2968, 525, 2299, + 2667, 1572, 3069, 1059, 1563, 3431, 1941, -540, 3530, 3494, + 1942, 1943, -540, 2972, 1944, 1945, 1946, 2901, 525, 525, + 3599, 1026, 2403, 525, 3227, 541, 525, 2756, 1156, 26, + 27, 28, 1059, 2362, 3513, 1941, 3583, 1027, 3352, 1942, + 1943, 3551, 3558, 1944, 1945, 1946, 1778, 1028, 3577, 3387, + -1359, 2649, 3063, 525, 2674, 3549, 2943, 2937, 3556, 2895, + 2856, 3022, 2645, -540, 3547, 1895, 2748, 1855, 2750, 2711, + 26, 27, 28, 525, 2761, 3281, 3044, 2633, 1705, 525, + 525, 1029, 872, -540, 525, 1572, 1463, 1464, 542, 525, + 2619, 1230, 525, 525, 2260, 1563, 33, 525, 1307, 1746, + 2786, 525, 1204, 1745, 3535, 525, 2629, 914, 2228, 3480, + 3408, 1231, 525, 2259, 811, 2605, 2230, 2497, 3282, 1750, + 3119, 3308, 2780, 1637, 2944, 2779, 1430, 1030, 523, 2945, + 3358, 2810, -540, 38, 1031, 2511, 3229, 33, 1414, 1416, + 1420, -540, 971, 1421, 2412, 1422, 2413, 1423, 2414, 1424, + 817, 1425, 1426, 3483, 1373, 3482, 525, 1232, 2959, 2558, + 2834, 546, 810, 972, 525, 2582, 40, 2622, 2960, 2580, + 2527, 3172, 2740, 3143, 38, 1991, 1032, 43, 2946, 2559, + 1465, 2853, 3470, 525, 2887, 2343, 549, 1907, 1211, 550, + 2504, 986, 1572, 3144, 2256, 1033, 2947, 2197, 1824, 2902, + 2199, 2694, 0, 0, 1950, 1951, 1952, 40, 1953, 1954, + 1955, 1956, 1957, 1958, 0, 0, 0, 1948, 43, 0, + 545, 2194, 0, 0, 0, 0, 3019, 2961, 0, 0, + 0, 0, 46, 0, 1373, 44, 0, 1373, 1373, 0, + 0, 0, 0, 0, 0, 0, 1948, 0, 0, 0, + 0, 0, 0, 1233, 0, 1561, 0, 0, 0, 45, + 0, 0, 0, 0, 1034, 0, 0, 0, 719, 1205, + 546, 0, 972, 2896, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 872, 1949, 0, 548, + 0, 0, -540, 2263, 2265, 549, 525, 2948, 550, 1913, + 0, 0, 1234, 0, 981, 0, 2949, 525, 1572, 0, + 0, 0, 1235, 0, 0, 0, 1949, 3264, 0, 1563, + 0, 0, 819, 525, 1236, 0, 2962, 0, 0, 0, + 0, 0, 1439, 1439, 1439, 1439, 1439, 1439, 0, 0, 1439, 1439, 1439, 1439, 1439, 1439, 1439, 1439, 1439, 1439, - 0, 0, 0, 1567, 0, 0, 0, 0, 2393, 1561, - 0, 0, 0, 0, -1848, 0, 1568, 0, 1947, 1566, - 1059, 0, 0, 1939, 0, 0, 0, 1940, 1941, -1848, - 0, 1942, 1943, 1944, -1848, 0, 0, 0, 0, -1848, - 0, 0, 0, 0, 0, 0, 0, 0, -1848, 0, - 0, 0, 0, -1848, 0, 3011, 0, 0, 1437, 1437, - 1437, 1437, 1437, 1437, 0, 0, 1437, 1437, 1437, 1437, - 1437, 1437, 1437, 1437, 1437, 1437, 0, 0, 0, 0, - 0, 0, 0, 0, 0, -1848, 0, 0, 0, 0, - 0, 0, 1563, 1907, 1909, 0, 557, 1564, 0, 0, - 0, 0, 0, 0, 1563, -1848, 1373, 0, 0, 1564, - 854, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 807, 0, 0, 0, 0, 0, 807, 0, 0, - 0, 0, 0, 557, 1563, 0, 0, 0, 557, 1564, - 1567, 1563, 0, 0, 0, 0, 1564, 2506, 2506, 0, - 0, 0, 0, 1568, -1848, 0, 0, -1848, 0, 0, - 0, 0, 0, -1848, 0, 0, 0, 0, 0, 1566, - 0, 1569, 0, 558, 0, 0, 0, 1439, 1439, 0, - 0, 1566, 1563, 0, 0, 0, 1563, 1564, 0, 0, - 0, 1564, 1563, 0, 0, 0, 0, 1564, 0, 0, - 0, 0, 0, -1848, 0, 1639, 0, 0, 1640, 0, - 995, 1566, 1641, 1642, 0, 1563, 0, 0, 1566, 557, - 1564, 0, 0, 0, 2549, 0, 0, 0, -1848, 557, - 0, 1948, 1949, 1950, -2102, 1951, 1952, 1953, 1954, 1955, - 1956, 0, 0, 1650, 0, 0, 0, 0, 0, 0, - -2102, 0, 0, 1437, 1437, 0, 0, 0, 0, 1566, - 0, 0, 0, 1566, 0, 0, 0, 0, 0, 1566, - 1561, 0, 2091, 0, 0, 0, 0, 1652, 1437, 0, - 0, 0, 0, 0, 0, 0, 859, 0, 14, 15, - 1567, 0, 1566, 1439, 0, 0, 0, 0, 0, 0, - 0, 0, 1567, 1568, 1947, 807, 1210, 0, 0, 0, - 0, 0, 0, 0, -1848, 1568, 0, 557, 0, 0, - 0, 0, 807, 0, -1848, 0, 2209, 0, 0, 0, - 0, 0, 1567, 0, 23, 0, 0, 0, 0, 1567, - 0, 1311, 2563, 0, -1848, 1568, -1848, -1848, 0, 0, - 0, 0, 1568, 0, 0, 0, 0, 1327, 1329, 1332, - 1334, 0, 0, 0, 558, 558, 557, 1373, 0, 1437, - 0, 1106, 557, 0, -2102, 0, 0, 0, 0, 0, - 1567, 0, 0, -1848, 1567, 0, -1848, -1848, -1848, 0, - 1567, -2102, 1842, 1568, 0, 0, -2102, 1568, 0, 0, - 0, 0, 0, 1568, 0, 0, 0, 0, 1432, 0, - 0, 0, 0, 1567, 0, 0, 0, 0, 0, 0, - 0, 0, 808, 0, 0, 0, 1568, 0, 0, 0, - 0, 0, 0, 0, -2102, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1842, 0, 0, 0, 0, 0, 0, - 854, 0, 0, 0, 0, 0, 0, 26, 27, 28, - 0, 1323, 0, 558, 1842, 854, 854, 854, 0, 1661, + 0, 1572, 2324, 0, 23, 0, 1237, 525, 0, 0, + 0, 912, 0, 0, 0, 913, 0, 0, 2340, 2340, + 0, 1909, 1911, 0, 525, 525, 0, 0, 525, 854, + 525, 0, 0, 0, 854, 0, 0, 854, 0, 0, + 0, 1561, 0, 0, 0, 557, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 525, 0, 0, 0, 0, + 1239, 0, 0, 0, 1563, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 2078, 0, 0, 2917, 525, + 0, 2918, 2079, 2080, 0, 1240, 2081, 2082, 2083, 0, + 0, 1370, 0, 0, 0, 0, 0, 2420, 0, 0, + 0, 0, 0, 0, 1242, 0, 2963, 1561, 2970, 2964, + 0, 3019, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3023, 3024, 3025, 3026, 3027, 3028, 3029, + 3030, 3031, 3032, 719, 0, 0, 14, 15, 853, 0, + 0, 0, 861, 0, 0, 0, 0, 26, 27, 28, + 1950, 1951, 1952, 525, 1953, 1954, 1955, 1956, 1957, 1958, + 0, 0, 3370, 525, 1913, 525, 0, 525, 0, 0, + 0, 525, 0, 525, 0, 525, 523, 1439, 1439, 1950, + 1951, 1952, 23, 1953, 1954, 1955, 1956, 1957, 1958, 525, + 0, 0, 0, 0, 525, 0, 525, 0, 817, 0, + 0, 1563, 897, 0, 525, 0, 0, 0, 0, 900, + 0, 903, 1561, 907, 33, 0, 0, 719, 0, 1788, + 0, 0, 525, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 961, 557, 557, 0, 3428, + 0, 3430, 0, 0, 0, 2070, 0, 0, 3437, 0, + 0, 38, 0, 0, 0, 0, 0, 2100, 0, 2101, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 525, + 0, 0, 0, 1564, 0, 0, 0, 984, 532, 525, + 0, 3463, 0, 521, 40, 854, 0, 2119, 0, 0, + 0, 525, 0, 1439, 807, 43, 0, 3466, 1011, 1011, + 0, 807, 0, 0, 1011, 1038, 525, 0, 0, 0, + 1561, 0, 44, 0, 0, 0, 0, 834, 834, 834, + 0, 0, 834, 0, 525, 26, 27, 28, 1916, 523, + 1106, 1106, 834, 834, 0, 834, 45, 834, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 525, 854, + 46, 817, 0, 1563, 0, 557, 0, 0, 0, 2620, + 0, 0, 0, 525, 0, 1563, 0, 854, 0, 0, + 819, 523, 3019, 0, 719, 1917, 0, 0, 0, 3208, + 0, 854, 822, 0, 0, 0, 0, 0, 0, 0, + 2240, 2240, 33, 817, 1561, 1563, 1918, 525, 2383, 0, + 0, 0, 1563, 35, 0, 3437, 0, 0, 0, 0, + 0, 525, 525, 525, 1919, 0, 854, 1312, 1920, 23, + 523, 0, 0, 3559, 0, 37, 0, 0, 1323, 38, + 0, 0, 854, 854, 854, 854, 0, 0, 525, 0, + 0, 1921, 817, 1563, 1922, 0, 0, 1563, 1344, 3574, + 0, 0, 0, 1563, 1373, 0, 0, 1564, 0, 0, + 1923, 0, 40, 0, 1373, 0, 0, 1373, 0, 0, + 0, 2678, 0, 43, 0, 0, 1563, 0, 1566, 525, + 1011, 1038, 0, 854, 0, 0, 1437, 1567, 0, 0, + 44, 0, 1011, 1011, 0, 0, 0, 0, 0, 557, + 0, 1561, 0, 0, 0, 807, 0, 807, 0, 71, + 0, 0, 0, 0, 45, 0, 807, 0, 0, 0, + 0, 0, 0, 819, 2708, 0, 557, 0, 46, 71, + 0, 0, 809, 0, 0, 1561, 0, 0, 0, 0, + 0, 0, 2723, 1576, 0, 1022, 71, 0, 1564, 0, + 1023, 0, 0, 1924, 0, 871, 0, 0, 0, 0, + 0, 1925, 26, 27, 28, 819, 1373, 0, 0, 0, + 0, 0, 2084, 2085, 2086, 0, 2087, 2088, 2089, 2090, + 2091, 2092, 0, 1926, 809, 809, 887, 1370, 0, 0, + 0, 0, 0, 0, 557, 0, 0, 2762, 0, 2763, + 0, 0, 0, 2768, 0, 2771, 0, 0, 0, 1024, + 71, 0, 1927, 0, 819, 0, 0, 1561, 0, 1439, + 1439, 0, 0, 0, 0, 0, 0, 0, 0, 33, + 0, 1639, 0, 0, 1640, 0, 0, 0, 1641, 1642, + 0, 930, -2102, -2102, -2102, 0, 937, 1699, 0, 938, + 0, 0, 0, 0, 0, 0, 3355, 0, 0, 0, + 1561, 0, 1566, 557, 557, 0, 38, 0, 0, 1650, + 854, 1567, 0, 0, 0, 0, 1651, 0, 3362, 3363, + 0, 1025, 0, 0, 0, 0, 0, 0, 0, 2515, + 0, 0, 0, 1437, 1106, 1106, 0, 0, 0, 40, + 0, -1833, 3376, 1652, 0, 854, 1777, 0, 0, 0, + 43, 1022, 0, 0, 0, 0, 1023, 1026, 854, 0, + 0, 0, 0, 0, 0, 0, 0, 44, 0, 0, + 0, 0, 0, 1027, 1568, 854, 0, 0, 0, 854, + 1217, 0, 0, 1028, 1825, 0, 1218, 0, 0, 0, + 0, 45, 0, 1566, 1230, 0, 0, 0, 0, 0, + 0, 0, 1567, 0, 0, 46, 0, 0, 0, 0, + 1561, 0, 1564, 0, 1231, 1024, 0, 1029, 0, 0, + 0, 0, 0, 0, 0, 3263, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1563, 0, 0, + 1653, -1833, 0, 1844, 0, 854, 23, 0, 0, 0, + 0, 0, 0, 0, 854, 1439, 0, 1654, 0, 0, + 1232, 1639, 1655, 1030, 1640, 1888, 0, 0, 1641, 1642, + 1031, 0, 0, 0, 961, 0, 0, 0, 0, 961, + 3113, 557, 557, 0, 557, 961, 2599, 1025, -1833, 0, + 0, 1219, 0, 0, 0, 0, 0, 0, 3012, 1650, + 1658, 0, 0, -1833, 0, 0, -2102, 1564, -1833, 0, + 0, 0, 1032, -1833, 0, 0, 0, 0, 0, 2625, + 2625, 0, -1833, 1026, 0, 0, 0, -1833, 0, 2708, + 3142, 1033, 0, 1652, 0, 0, 0, 995, 0, 1027, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1028, + 0, 0, 0, 0, 0, 1661, 1233, 0, 1568, -1833, + 0, 0, 0, 0, 1437, 1437, 0, 0, 0, 0, + 1437, 0, 521, 1563, 3543, 0, 0, 0, 0, -1833, + 0, 0, 0, 1029, 0, 1011, 0, 557, 1984, 26, + 27, 28, 1106, 1106, 0, 854, 0, 0, 2566, 0, + 1034, 807, 0, 807, 2007, 1234, 807, 0, 0, 0, + 0, 807, 0, 1106, 807, 1235, 807, 1566, 0, 0, + 807, 1439, 557, 0, 557, 0, 1567, 1236, -1833, 1030, + -2102, -1833, 0, 1210, 0, 0, 1031, -1833, 0, 1563, + 0, 0, 0, 0, 1564, 0, 0, -2102, 1220, 1568, + 0, 0, -2102, 0, 0, 0, 33, 1663, 0, 1237, + 0, 0, 0, 0, 0, 0, 0, 0, 1311, 0, + 0, 1561, 0, 0, 0, 0, 0, -1833, 1032, 0, + 0, 0, 0, 0, 1327, 1329, 1332, 1334, 71, 0, + -2102, 0, 0, 38, 0, 0, 0, 1033, 0, 0, + 0, 0, -1833, 0, 3170, 0, 0, 2301, 0, 0, + 0, 1222, 1566, 1239, 0, 0, 0, 558, 0, 0, + 0, 1567, 0, 558, 0, 0, 40, 808, 0, 2093, + 0, 0, 0, 0, 558, 1432, 0, 43, 1240, 0, + 0, 557, 0, 2302, 1563, 1661, 0, 0, 558, 558, + 0, 0, 0, 0, 44, 0, 0, 1242, 0, 0, + 859, 0, 0, 0, 1439, 1664, 1034, 0, -2102, -2102, + -2102, 2008, 1668, 1669, 1670, 1671, 1672, 1673, 45, 808, + 808, 961, 0, 0, 1437, 0, 0, 0, -1833, 0, + 0, 0, 46, 0, 0, 0, 1564, 0, -1833, 0, + 0, 0, 0, 0, 0, 0, 2818, 2820, 1564, 0, + 0, 0, 1106, 558, 1224, 0, 0, 0, -1833, 0, + -1833, -1833, 0, 0, 0, 0, 0, 2195, 0, 854, + 0, 854, 0, 0, 0, 0, 0, 0, 1564, 0, + 0, 854, 1563, 2211, 0, 1564, 0, -2102, 0, 1566, + 0, 0, 0, 0, 0, 1437, 0, -1833, 1567, 0, + -1833, -1833, -1833, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3259, 1568, 0, 0, 0, 0, 1230, 0, + 854, 0, 557, 0, 0, 0, 1564, 0, 0, 0, + 1564, 0, 0, 0, 2262, 2264, 1564, 0, 1231, 1370, + 1777, 557, 71, 871, 0, 0, 0, 0, 0, 0, + 0, 557, 2281, 557, 2285, 0, 557, 0, 0, 1564, + 0, 0, 557, 0, 557, 0, 1563, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 961, 557, 0, 0, + 0, 961, 557, 991, 1232, 0, 557, 557, 557, 557, + 0, 557, 557, 0, 1003, -2102, 0, 1769, 0, 0, + 0, 1019, 1668, 1669, 1670, 1671, 1672, 1673, 1568, 0, + 1796, 2344, 0, 1373, 0, 0, 0, 0, 0, 1323, + 3414, 854, 854, 854, 854, 854, 3329, 0, 0, 0, + 0, 1821, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1566, 2373, 0, 0, 0, 887, 0, 0, 0, + 1567, 0, 0, 1566, 0, 0, 0, 0, 0, 0, + 0, 2396, 1567, 0, 71, 0, 0, 0, 0, 0, + 0, 0, 0, 1563, 0, 0, 0, 0, 0, 0, + 1233, 0, 0, 1566, 0, 0, 0, 0, 0, 0, + 1566, 0, 1567, 0, 0, 0, 3012, 1849, 0, 1567, + 0, 0, 0, 0, 0, 0, 1868, 1563, 0, 0, + 0, 1437, 1437, 1437, 1437, 1437, 1437, 0, 0, 1437, + 1437, 1437, 1437, 1437, 1437, 1437, 1437, 1437, 1437, 1234, + 0, 1566, 0, 0, 0, 1566, 0, 0, 0, 1235, + 1567, 1566, 0, 0, 1567, 1568, 3126, 11, 0, 557, + 1567, 1236, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 854, 1566, 0, 0, 0, 0, 0, + 0, 0, 71, 1567, 807, 14, 15, 0, 0, 0, + 807, 0, 0, 1237, 0, 0, 557, 0, 0, 1563, + 0, 557, 0, 0, 0, 0, 0, 0, 0, 0, + 2509, 2509, 0, 0, 0, 809, 0, 1003, 0, 0, + 0, 0, 0, 0, 0, 0, 809, 0, 0, 0, + 0, 23, 0, 1639, 3456, 0, 1640, 0, 0, 23, + 1641, 1642, 1563, 0, 0, 0, 0, 1239, 0, 0, + 0, 1639, 0, 0, 1640, 0, 0, 1998, 1641, 1642, + 0, 1579, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1650, 1240, 1591, 0, 0, 0, 0, -2102, 0, + 0, 0, 557, 0, 0, 0, 0, 2552, 0, 1650, + 1564, 1242, 557, 0, 0, 0, -2102, 0, 0, 0, + 1618, 1373, 0, -1848, 0, 1652, 1373, 1568, 0, 0, + 558, 0, 0, 0, 0, 0, 1437, 1437, 0, 1568, + 0, 0, 0, 1652, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 2093, 0, 0, 0, 0, + 0, 1437, 0, 0, 0, 0, 0, 0, 0, 1568, + 0, 0, 1563, 1909, 1911, 0, 1568, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3012, 807, 0, + 2576, 3429, 0, 0, 26, 27, 28, 0, 0, 0, + 557, 0, 26, 27, 28, 807, 0, 887, 887, 2211, + 887, 0, 0, 0, 0, 0, 0, 1568, 0, 0, + 0, 1568, -2102, -1848, 0, 0, 0, 1568, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, -2102, + -2102, 0, 0, 0, -2102, 0, 1564, 0, 0, 557, + 1568, 0, 1437, 0, 1106, 557, 0, -2102, 0, 0, + 0, 33, -2102, 0, 0, 0, 0, 0, 0, 33, + -1848, 0, 35, 0, 0, 1844, 0, 0, 0, 0, + 0, 0, -2102, 0, 0, -1848, 0, 0, 0, 0, + -1848, 0, 0, 0, 37, -1848, 0, 0, 38, 0, + -2102, 0, 0, 0, -1848, 0, 38, 0, 0, -1848, + 0, 2196, 1564, 2198, 0, 1566, 0, 0, 39, 0, + 0, 558, 558, 2208, 1567, 0, 0, 0, 0, 0, + 0, 40, 0, 0, 0, 0, 0, 1661, 0, 40, + 0, -1848, 43, 0, 0, 0, 0, 1844, 0, 0, + 43, 0, 0, 0, 854, 1661, 0, 0, 0, 44, + 0, -1848, 2245, 0, 0, 1323, 0, 44, 1844, 854, + 854, 854, 0, 0, 0, 0, 0, 0, 0, 808, + 0, 71, 557, 45, 854, 0, 0, 854, 1909, 1911, + 0, 45, 0, 0, 854, 0, 0, 46, 0, 0, + 961, 1373, 0, 0, 0, 46, 0, 0, 0, 0, + -1848, 0, 0, -1848, 0, 0, 0, 1564, 0, -1848, + 0, 0, 1844, 1844, 0, 1844, 0, 0, 0, 0, + 0, 0, 0, 1563, 0, 0, 0, 0, 0, -2102, + 558, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1566, 0, 0, 521, 0, 0, -2102, 0, -1848, + 1567, 0, 0, 2356, 2357, 2359, 2360, 2361, 0, 0, + 0, 0, 2785, 0, 0, 0, 0, 0, 0, 0, + 854, 854, 854, 0, -1848, 0, 0, 0, 0, 0, + 557, 809, 1437, 809, 557, 0, 809, 0, 0, 0, + 557, 809, 0, 0, 809, 0, 809, 0, 0, 0, + 809, 0, 0, 0, 0, 1564, 1059, 1566, 0, 1941, + 854, 0, 0, 1942, 1943, 0, 1567, 1944, 1945, 1946, + 0, 0, 0, 0, 2093, 0, 0, 0, 0, 0, + 0, 0, 859, 0, 2857, 557, 0, -2102, 0, 557, + 0, 0, 0, 0, 1668, 1669, 1670, 1671, 1672, 1673, + 0, 0, 0, 0, 0, -2102, 0, 0, 0, 0, + -1848, 1568, 1668, 1669, 1670, 1671, 1672, 1673, 1437, 1437, + -1848, 0, 0, 0, 1457, 0, 0, 0, 0, 0, + 808, 0, 808, 71, 0, 0, 0, 0, 0, 1564, + -1848, 808, -1848, -1848, 0, 2480, 0, 2891, 0, 0, + 0, 1494, 0, 2211, 0, 0, 0, 0, 0, 0, + 0, 0, 1566, 0, 0, 0, 0, 0, 0, 854, + 0, 1567, 0, 557, 0, 1106, 0, 557, 557, -1848, + 0, 557, -1848, -1848, -1848, 1844, 1777, 1844, 1059, 1888, + 0, 1941, 0, 0, 0, 1942, 1943, 0, 0, 1944, + 1945, 1946, 1373, 0, 0, 0, 0, 0, 557, 0, + 2971, 0, 0, 0, 2143, 0, 3151, 0, 0, 1623, + 0, 0, 0, 557, 557, 557, 557, 557, 557, 557, + 557, 557, 557, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1564, 1568, 0, 0, + 0, 0, 0, 0, 2373, 0, 0, 0, 0, 0, + 1566, 854, 0, 0, 0, 0, 0, 0, 0, 1567, + 1948, 0, 0, 1777, 0, 0, 0, 0, 0, 0, + 1564, 0, 887, 0, 0, 0, 0, 1059, 558, 558, + 1941, 0, 0, 1888, 1942, 1943, 0, 0, 1944, 1945, + 1946, 0, 0, 1844, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1568, 1437, 3152, 0, 0, 0, 0, + 557, 0, 0, 0, 0, 0, 0, 854, 854, 854, + 854, 0, 0, 0, 0, 0, 0, 0, 0, 1437, + 1949, 0, 1437, 0, 1566, 0, 557, 961, 0, 0, + 0, 0, 0, 1567, 0, 3128, 0, 0, 1639, 0, + 0, 1640, 1564, 0, 0, 1641, 1642, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 557, 0, - 854, 0, 0, 854, 0, 0, 0, 0, 0, 0, - 854, 0, 0, 0, 0, 0, 961, 1948, 1949, 1950, - 0, 1951, 1952, 1953, 1954, 1955, 1956, 0, 0, 0, - 0, 0, 0, 0, 0, 1563, 0, 0, 1842, 1842, - 1564, 1842, 0, 0, 33, 1639, 0, 0, 1640, 0, - 0, 0, 1641, 1642, 0, 35, 0, 0, 0, 0, - 0, 0, 0, 0, 1440, 0, 0, 0, 0, 0, - 521, 0, 0, 0, 0, 0, 0, 37, 0, 0, - 0, 38, 0, 1650, 0, 0, 0, 0, 2784, 0, - -2102, -2102, 0, 0, 0, 0, 854, 854, 854, 0, - 0, 0, 0, 0, 0, 0, 557, 0, 1437, 0, - 557, 0, 1566, 0, 40, 0, 557, 1652, 1439, 1439, - 0, 0, 0, 0, 0, 43, 0, 1457, 0, 0, - 1769, 0, 0, 808, 0, 808, 854, 0, 0, 0, - 0, 0, 44, 1796, 808, 0, 0, 0, 0, 0, - 2091, 0, 0, 0, 1494, 0, 0, 0, 0, 0, - 0, 557, 0, 0, 1821, 557, 45, 0, 0, 0, - 0, 1563, 0, 0, 0, 0, 1564, 0, 0, 0, - 46, 0, 2573, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1437, 1437, 0, 0, 0, -2102, - 0, 0, 0, 0, 0, 0, 1668, 1669, 1670, 1671, - 1672, 1673, 0, 0, -2102, 0, 0, 0, 0, 0, - 0, 0, 1623, 2890, 0, 0, 0, 0, 0, 2209, - 1847, -2102, 0, 1567, 0, 0, -2102, 1563, 0, 1866, - 0, 0, 1564, 0, 0, 854, 1568, 0, 1566, 557, - 0, 1106, 0, 557, 557, 0, 0, 557, 0, 0, - 0, 1842, 1777, 1842, 0, 1886, 0, 0, 0, 0, - 0, 1440, 0, 0, -2102, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 557, 0, 2970, 0, 0, 0, - 0, 558, 558, 0, 0, 0, 0, 0, 0, 557, - 557, 557, 557, 557, 557, 557, 557, 557, 557, 0, - 0, 0, 0, 0, 1566, 0, 1439, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1661, - 0, 0, 2370, 0, 0, 0, 0, 0, 0, 854, - 0, 3112, 1563, 0, 0, 0, 0, 1564, 0, 0, - 0, 1777, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1567, - 0, 1886, 0, 0, 0, 0, 0, 0, 0, 0, - 1996, 1842, 1568, 0, 0, 0, 0, 0, 0, 0, - 0, 3141, 1437, 0, 0, 0, 0, 0, 557, 0, - 0, 0, 0, 0, 0, 854, 854, 854, 854, 1230, - 0, 0, 0, 0, 0, 0, 0, 1437, 0, 1566, - 1437, 0, 0, 0, 557, 961, 0, 0, 0, 1231, - 0, -2102, 0, 3127, 0, 1567, 0, 0, 0, 0, - 0, 0, 1563, 0, 0, 0, 0, 1564, 1568, 0, - 0, 0, 0, 0, 0, 0, 557, 0, 0, 0, - 0, 0, 0, 3135, 557, 0, 0, 0, 2549, 558, - 558, 0, 558, 0, 0, 1232, 2958, 0, 0, 0, - 0, 0, 1439, 0, 0, 0, 2959, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 3164, 0, 807, - 0, 0, 1440, 1440, 0, 0, 1106, 0, 1440, 0, - 0, 0, 0, 3176, 0, 0, 0, 2209, 0, 1566, - 0, 0, 0, 2091, 0, 0, 1563, 0, 0, 0, - 0, 1564, 0, 0, 0, 0, 0, 1777, 0, -2102, - 1567, 0, 0, 1842, 0, 2960, 1668, 1669, 1670, 1671, - 1672, 1673, 0, 1568, 0, 0, 961, 557, 1437, 0, - 0, 0, 0, 0, 854, 0, 0, 0, 0, 0, - 0, 1233, 0, 0, 0, 558, 0, 0, 0, 0, - 0, 3227, 0, 0, 0, 0, 0, 0, 0, 808, - 0, 808, 0, 0, 808, 0, 0, 0, 0, 808, - 0, 0, 808, 1566, 808, 0, 0, 0, 808, 0, - 2017, 0, 2021, 0, 2194, 0, 2196, 0, 0, 0, - 1234, 0, 0, 0, 0, 1439, 2206, 0, 0, 0, - 1235, 0, 0, 1563, 0, 0, 0, 0, 1564, 0, - 1567, 0, 1236, 0, 2961, 0, 0, 0, 0, 0, - 0, 0, 0, 1568, 0, 0, 0, 0, 0, 3245, - 0, 0, 0, 1842, 0, 2243, 0, 1563, 0, 0, - 0, 0, 1564, 0, 1237, 0, 2370, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 3277, 0, 0, 0, 0, 0, - 0, 1437, 0, 0, 0, 0, 0, 0, 0, 0, - 1566, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1567, 0, 0, 3294, 1239, 2102, - 0, 0, 0, 557, 0, 0, 0, 1568, 0, 0, - 557, 1386, 0, 821, 1566, 0, 0, 0, 2185, 1563, - 0, 0, 0, 1240, 1564, 0, 0, 3313, 0, 0, - 0, 0, 0, 0, 2353, 2354, 2356, 2357, 2358, 0, - 0, 0, 1242, 0, 2962, 0, 0, 2963, 0, 0, - 0, 3325, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1563, 1440, 0, 0, 0, 1564, 0, 0, - 0, 0, 0, 557, 0, 0, 1387, 1388, 557, 0, + 0, 0, 0, 0, 0, 3136, 557, 0, 0, 0, + 2552, 0, 0, 0, 0, 0, 1650, 0, 0, 0, + 0, 0, 1948, -2102, 0, 1564, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1568, 3165, + 0, 807, 2365, 0, 0, 0, 0, 0, 1106, 0, + 1652, 0, 0, 0, 71, 3177, 0, 0, 0, 2211, + 0, 0, 0, 0, 0, 2093, 0, 0, 0, 0, + 0, 1566, 0, 0, 0, 0, 0, 0, 0, 1777, + 1567, 0, 0, 0, 0, 1844, 558, 558, 0, 558, + 0, 0, 1949, 0, 0, 0, 0, 0, 961, 557, + 1437, 0, 0, 0, 0, 1566, 854, 0, 0, 0, + 0, 0, 0, 0, 1567, 2866, 0, 0, 0, 0, + 0, 1948, 0, 3228, 0, 0, 2713, 0, 0, 0, + 0, 0, 0, 0, 0, 1564, 1568, 0, 0, 0, + 0, 2729, 2730, 2732, 0, 0, 0, -2102, 0, 0, + 0, 0, 0, 0, 0, 0, 2743, 0, 0, 2746, + 0, 0, 0, 0, -2102, 0, 2755, 0, 0, -2102, + 0, 0, 0, 1950, 1951, 1952, 0, 1953, 1954, 1955, + 1956, 1957, 1958, 0, 809, 0, 0, 1566, 0, 0, + 809, 1949, 558, 0, 0, 0, 1567, 0, 0, 0, + 0, 3246, 0, 0, 0, 1844, 808, -2102, 808, 0, + 0, 808, 0, 0, 0, 0, 808, 0, 2373, 808, + 1568, 808, 0, 0, 0, 808, 0, 2019, 0, 2023, + 1566, 0, 0, 0, 0, 0, 3278, 0, 0, 1567, + 0, 0, 0, 1437, 0, 0, 0, 0, 0, 0, + 0, 0, 2792, 2793, 2794, 0, 0, 0, 0, 0, + 0, 0, 1661, 0, 0, 0, 0, 0, 0, 3295, + 0, 0, 0, 0, 0, 557, 0, 0, 0, 0, + 0, 0, 557, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 3314, + 0, 0, 0, 0, 0, 1950, 1951, 1952, 0, 1953, + 1954, 1955, 1956, 1957, 1958, 0, 0, 0, 0, 0, + 0, 1618, 0, 3326, 0, 0, 0, 1568, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1566, 0, 0, 0, - 0, 1567, 0, 0, 557, 0, 0, 0, 0, 0, - 0, 3413, 0, 0, 1568, 0, 0, 1389, 1390, 0, - 0, 1391, 1392, 0, 0, 0, 557, 557, 0, 0, - 0, 0, 0, 0, 0, 1567, 0, 0, 0, 1566, - 558, 0, 0, 854, 0, 1777, 0, 0, 1568, 0, - 557, 0, 0, 0, 0, 0, 0, 1788, 0, 558, - 0, 0, 0, 0, 854, 0, 0, 3396, 0, 558, - 0, 558, 1563, 0, 558, 0, 2477, 1564, 0, 0, - 558, 0, 558, 0, 0, 0, 0, 1437, 0, 1106, - 0, 557, 1011, 0, 1011, 558, 0, 1393, 1394, 557, - 558, 0, 0, 0, 558, 558, 558, 558, 0, 558, - 558, 0, 0, 0, 0, 0, 0, 1567, 1106, 0, - 0, 0, 3176, 0, 0, 0, 0, 0, 0, 854, - 1568, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1566, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 854, - 1567, 1395, 1396, 1397, 1398, 1399, 1400, 1401, 1402, 0, - 0, 1403, 1404, 1568, 0, 0, 0, 1440, 1440, 1440, - 1440, 1440, 1440, 0, 0, 1440, 1440, 1440, 1440, 1440, - 1440, 1440, 1440, 1440, 1440, 0, 0, 3294, 0, 0, - 0, 0, 0, 0, 0, 1106, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 3396, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1405, 1406, 1777, 0, 0, - 0, 0, 0, 1121, 1121, 0, 0, 0, 0, 961, - 961, 0, 3396, 961, 0, 558, -46, 0, 0, 0, - 1567, 1982, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 557, 1568, 0, 0, 1407, 1408, 1, 0, - 808, 0, 0, 0, 722, 0, 808, 0, 2, 0, - 3, 4, 2493, 0, 1777, 0, 0, 2021, 0, 0, - 0, 3396, 0, 5, 0, 0, 0, 0, 6, 0, - 0, 0, 0, 0, 1259, 0, 0, 7, 1302, 1309, - 0, 0, 0, 1563, 0, 0, 0, 0, 1564, 0, - 0, 8, 0, 0, 0, 0, 1639, 0, 961, 1640, - 9, 723, 10, 1641, 1642, 1643, 1644, 1645, 1646, 1647, - 0, 0, 0, 2209, 11, 0, 12, 724, 0, 0, - 0, 0, 1440, 1440, 1648, 0, 0, 13, 0, 0, - 0, 1359, 1409, 1410, 1650, 0, 0, 0, 2102, 0, - 0, 1651, 14, 15, 16, 0, 0, 0, 1623, 1383, - 0, 0, 0, 17, 0, 1431, 1411, 1412, 1433, 18, - 1566, 1444, 1447, 1452, 1455, 0, 725, 19, 1652, 20, - 21, 0, 0, 0, 0, 0, 726, 0, 0, 0, - 0, 0, 0, 0, 22, 0, 2712, 0, 23, 727, - 0, 0, 0, 0, 728, 0, 0, 0, 0, 0, - 0, 2728, 2729, 2731, 0, 0, 1498, 1302, 0, 0, - 0, 0, 0, 0, 24, 0, 2742, 0, 0, 2745, - 0, 0, 0, 729, 808, 0, 2754, 0, 1582, 0, - -1468, 0, 0, 0, 0, 0, 558, 0, 1440, 0, - 0, 808, 0, 0, 0, 0, 0, 1598, 0, 0, - 0, 0, 0, 0, 0, 0, 25, 0, 1608, 1609, - 1610, 0, 1615, 1619, 0, 1653, 730, 0, 0, 0, - 731, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1567, 1654, 0, 0, 558, 0, 1655, 0, 0, - 0, 2634, 0, 0, 1568, 0, 0, 0, 1682, 0, + 1566, 2143, 0, 0, 0, 557, 2104, 0, 0, 1567, + 557, 0, 0, 0, 0, 0, 0, 2586, 0, 0, + 0, 1568, 0, 0, -2102, 0, 0, 0, 809, 0, + 0, 1059, 0, 0, 1941, 0, 557, 0, 1942, 1943, + 0, 0, 1944, 1945, 1946, 809, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1564, 0, 557, 557, + 0, 2909, 0, 0, 1950, 1951, 1952, 0, 1953, 1954, + 1955, 1956, 1957, 1958, 0, 854, 0, 1777, 0, 0, + 0, 0, 557, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 854, 0, 0, 3397, + 0, 0, 0, 1568, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1437, + 0, 1106, 0, 557, 1011, 0, 1011, 0, 0, 0, + 0, 557, -2102, 0, 0, 0, 0, 0, 0, 1668, + 1669, 1670, 1671, 1672, 1673, 0, 1568, 558, 0, 0, + 1106, 0, 0, 3052, 3177, 0, 0, 0, 0, 0, + 1639, 854, 0, 1640, 0, 0, 558, 1641, 1642, 0, + 0, 0, 0, 0, 0, 0, 558, 0, 558, 0, + 0, 558, 0, 0, 0, 0, 0, 558, 0, 558, + 0, 854, 0, 0, 0, 0, 0, 0, 1650, 0, + 0, 0, 558, 871, 0, -2102, 0, 558, 0, 0, + 0, 558, 558, 558, 558, 0, 558, 558, 0, 3092, + 3093, 3094, 3095, 0, 0, 0, 0, 0, 0, 3295, + 0, 0, 1652, 0, 0, 0, 0, 1106, 0, 0, + 0, 0, 0, 0, 0, -2102, 0, 0, 0, 0, + 0, 0, 3397, 0, 0, 0, 1568, 0, 0, 0, + 0, 1566, 0, 0, -46, 0, 0, 0, 0, 0, + 1567, 0, 0, 0, 0, 0, 0, 0, 0, 1777, + 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 961, 961, 0, 3397, 961, 2, 2869, 3, 4, + 0, 0, 0, 1984, 0, 0, 1121, 1121, 0, 0, + 0, 5, 0, 0, 557, 1949, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 7, 0, 0, 0, -2102, + 0, 0, 0, 0, 0, 0, 1777, 0, 0, 8, + 0, 0, 0, 3397, 0, 0, -2102, 0, 9, 0, + 10, -2102, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 11, 0, 12, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 558, 13, 0, 1259, 3215, 0, + 961, 1302, 1309, 0, 0, 0, 1618, 0, 0, -2102, + 14, 15, 16, 0, 0, 2211, 0, 0, 0, 808, + 0, 17, 0, 0, 0, 808, 0, 18, 0, 0, + 0, 2496, 0, 0, 0, 19, 2023, 20, 21, 0, + 0, 0, 0, 0, 1618, 0, 0, 0, 0, 0, + 0, 0, 22, 0, 1359, 0, 23, 0, 0, 0, + 0, 0, 0, 71, 1661, 0, 0, 0, 0, 71, + 0, 0, 1383, 0, 0, 0, 0, 0, 1431, 0, + 0, 1433, 24, 0, 1444, 1447, 1452, 1455, 0, 0, + 0, 0, 0, 0, 0, 2913, 0, 0, -1468, 0, + 0, 0, 1639, 0, 0, 1640, 0, 0, 0, 1641, + 1642, 0, 0, 1645, 1646, 1647, 0, 2104, 0, 0, + 0, 0, 0, 0, 25, 0, 0, 1623, 0, 1498, + 1302, 0, 0, 0, 0, 0, 0, 1568, 0, 0, + 1650, 0, 0, 0, 0, 0, 0, 1651, 1950, 1951, + 1952, 1582, 1953, 1954, 1955, 1956, 1957, 1958, 0, 0, + 1639, 0, 0, 1640, 0, 0, -2102, 1641, 1642, 0, + 1598, 1645, 1646, 1647, 1652, 71, 0, 0, 0, 0, + 0, 1608, 1609, 1610, 0, 1615, 1619, 0, 1648, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1650, 26, + 27, 28, 0, 808, 71, 1651, 0, 29, 0, 0, + 30, 3074, 0, 0, 0, 558, 0, 0, 0, 0, + 808, 1682, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1652, 0, 0, 0, 0, 0, 0, 1498, + 1498, 31, 0, 0, 0, 0, 1386, 0, 821, 0, + 32, 0, 0, 0, 0, 0, 0, 0, 0, 1618, + 0, 0, 0, 0, 558, 0, 33, 0, 0, 0, + 2637, 1653, 0, 34, -2102, 1720, 0, 35, 0, 1736, + 1741, 1668, 1669, 1670, 1671, 1672, 1673, 36, 1654, 0, + 1121, 1121, 0, 1655, 0, 0, 0, 0, 0, 37, + 0, 0, 0, 38, 0, 0, 0, 3371, 0, 0, + 0, 1387, 1388, 0, 0, 0, 1656, 1657, 0, 0, + 0, 0, 0, 39, 0, 0, 0, 0, 3395, 1653, + 0, 1658, 0, 0, 0, 0, 40, 0, 0, 41, + 0, 809, 42, 0, 0, 0, 1654, 43, 0, 0, + 1302, 1655, 1389, 1390, 0, 871, 1391, 1392, 0, 1302, + 0, 0, 0, 0, 44, 0, 0, 0, 0, 1659, + 0, 0, 1660, 0, 1656, 1657, 0, 0, 0, 0, + 0, 0, 0, 1302, 0, 0, 1661, 0, 45, 1658, + 0, 0, 0, 3435, 0, 0, 0, 558, 0, 0, + 0, 0, 46, 1639, 0, -46, 1640, 0, 0, 0, + 1641, 1642, 1643, 1644, 1645, 1646, 1647, 0, 0, 0, + 0, 0, 0, 3461, 0, 0, 0, 1659, 0, 0, + 1660, 1648, 1393, 1394, 0, 0, 0, 0, 0, 0, + 0, 1650, 0, 0, 1661, 0, 0, 1662, 1651, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1656, 1657, 2791, 2792, 2793, 0, 1498, 1498, 0, 0, - 0, 0, 0, 0, 0, 1658, 0, 0, 0, 0, - 0, 26, 27, 28, 544, 0, 0, 0, 0, 29, - 732, 0, 30, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1720, 0, 0, 733, 1736, 1741, 0, 0, - 0, 0, 0, 1659, 0, 0, 1660, 1121, 1121, 0, - 0, 0, 0, 31, 0, 0, 0, 0, 0, 0, - 1661, 0, 32, 1662, 0, 0, 0, 0, 0, 0, - 734, 0, 0, 735, 0, 0, 0, 0, 33, 0, - 0, 0, 0, 0, 736, 34, 1217, 737, 0, 35, - 0, 0, 1218, 0, 0, 0, 0, 558, 0, 36, - 1230, 0, 0, 0, 0, 738, 0, 1302, 0, 0, - 0, 37, 0, 0, 0, 38, 1302, 0, 0, 739, - 1231, 0, 0, 0, 0, 740, 741, 0, 0, 0, - 0, 0, 0, 0, 0, 39, 742, 0, 0, 0, - 1302, 2908, 743, 0, 0, 0, 0, 0, 40, 0, - 0, 41, 0, 0, 42, 0, 0, 0, 0, 43, - 0, 0, 1663, 0, 0, 0, 1232, 0, 0, 0, - 744, 0, 0, 0, 0, 0, 44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1219, 0, 0, - 45, 0, 0, 0, 0, 558, 0, 0, 0, 558, - 0, 0, 0, 0, 46, 2017, 0, -46, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1929, 0, 0, - 0, 0, 0, 0, 0, 3051, 0, 0, 0, 0, - 0, 0, 0, 1440, 1440, 0, 0, 0, 0, 0, + 1931, 0, 0, 0, 0, 1652, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1663, 0, + 0, 0, 0, 0, 0, 0, 1395, 1396, 1397, 1398, + 1399, 1400, 1401, 1402, 0, 558, 1403, 1404, 0, 558, + 0, 0, 0, 0, 0, 2019, 0, 0, 0, 71, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 2840, 0, 1233, 0, 2102, 0, 0, 0, 0, 0, - 1664, 0, 0, 1665, 1666, 1667, 0, 1668, 1669, 1670, - 1671, 1672, 1673, 0, 0, 0, 0, 0, 0, 0, - 1452, 2529, 1452, 1452, 0, 0, 0, 0, 0, 0, - 0, 3091, 3092, 3093, 3094, 1121, 1121, 0, 0, 0, - 0, 1234, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1235, 0, 0, 0, 0, 1121, 0, 0, 0, - 0, 0, 0, 1236, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1452, 0, 1452, 1452, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1663, 0, 1121, 1121, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1618, + 2841, 0, 0, 0, 2104, 0, 0, 0, 0, 1121, + 0, 0, 1653, 0, 0, 0, 0, 0, 0, 0, + 1405, 1406, 0, 0, 0, 0, 0, 0, 0, 1654, + 0, 0, 0, 0, 1655, 0, 1664, 0, 0, 1665, + 1666, 1667, 0, 1668, 1669, 1670, 1671, 1672, 1673, 0, + 0, 0, 0, 0, 0, 0, 0, 1656, 1657, 0, + 0, 1407, 1408, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1658, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 558, 0, - 0, 0, 558, 558, 1220, 0, 558, 0, 0, 0, - 0, 0, 0, 0, 0, 1237, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 558, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 558, 558, + 0, 0, 558, 558, 1664, 0, 558, 1665, 1666, 1667, + 0, 1668, 1669, 1670, 1671, 1672, 1673, 0, 0, 0, + 1659, 2068, 0, 1660, 1639, 0, 0, 1640, 0, 2071, + 0, 1641, 1642, 558, 0, 0, 0, 1661, 0, 0, + 1662, 0, 0, 0, 0, 0, 0, 0, 558, 558, 558, 558, 558, 558, 558, 558, 558, 558, 0, 0, - 0, 0, 0, 2299, 0, 0, 0, 1222, 0, 1239, - 0, 0, 0, 0, 0, 0, 0, 0, 2066, 0, - 0, 0, 0, 0, 0, 0, 2069, 0, 0, 0, - 0, 1440, 0, 0, 1240, 0, 0, 0, 0, 2300, + 0, 0, 1650, 2116, 71, 0, 0, 1409, 1410, -2102, + 2120, 0, 0, 0, 0, 0, 2124, 2125, 2126, 2127, + 2128, 2129, 2130, 2131, 0, 3394, 0, 0, 2140, 2141, + 0, 1411, 1412, 2154, 0, 0, 1652, 2157, 0, 0, + 2165, 2166, 2167, 2168, 2169, 2170, 2171, 2172, 2173, 0, + 0, 2174, 0, 0, 0, 0, 0, 0, 1121, 1639, + 1302, 0, 1640, 0, 0, 0, 1641, 1642, 1643, 1644, + 1645, 1646, 1647, 0, 0, 0, 0, 0, 2200, 1663, + 0, 71, 0, 71, 0, 2019, 0, 1648, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1650, 0, 0, + 0, 2870, 0, 0, 1651, 0, 0, 0, 0, 0, + 0, 2496, 1609, 1610, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 71, 0, 0, 0, 0, 0, 0, + 0, 1652, 0, -2102, 1639, 0, 0, 1640, 0, 71, + 0, 1641, 1642, 2104, 0, 1645, 1646, 1647, 0, 0, + -2102, 2104, 0, 0, 0, -2102, 0, 0, 0, 0, + 0, 0, 1648, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1650, 0, 0, 0, 0, 0, 0, 1651, + 0, 0, 0, 0, 0, 0, 808, 1664, 0, 0, + 1665, 1666, 1667, -2102, 1668, 1669, 1670, 1671, 1672, 1673, + 0, 0, 0, 2326, 0, 0, 1652, 0, 2532, 0, + 1302, 0, 0, 2337, 2338, 0, 0, 0, 0, 1638, + 0, 0, 0, 0, 1639, 0, 0, 1640, 1653, 0, + 0, 1641, 1642, 1643, 1644, 1645, 1646, 1647, 0, 0, + 0, 0, 0, 0, 558, 1654, 0, 0, 1661, 0, + 1655, 0, 1648, 0, 1302, 0, 1649, 0, 0, 0, + 0, 0, 1650, 0, 0, 71, 0, 0, 0, 1651, + 0, 0, 0, 1656, 1657, 0, 0, 0, 0, 1359, + 2404, 0, 0, 0, 0, 0, 0, 0, 1658, 0, + 0, 71, 0, 0, 0, 0, 1652, 0, 0, 0, + 0, 0, 0, 1653, 0, 0, 0, 0, 2430, 2431, + 0, 2432, 1441, 0, 0, 0, 0, 0, 0, 0, + 1654, 0, 0, 0, 0, 1655, 1659, 0, 0, 1660, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 3214, 0, 0, 1242, 0, 0, 1440, 0, 0, 0, - 2114, 0, 0, 0, 0, 0, 0, 2118, 0, 0, - 0, 0, 0, 2122, 2123, 2124, 2125, 2126, 2127, 2128, - 2129, 0, 0, 0, 0, 2138, 2139, 2017, 0, 0, - 2152, 0, 0, 0, 2155, 0, 0, 2163, 2164, 2165, - 2166, 2167, 2168, 2169, 2170, 2171, 0, 0, 2172, 0, - 1224, 0, 0, 2493, 0, 1121, 0, 1302, 0, 0, - 0, 1639, 0, 0, 1640, 0, 0, 0, 1641, 1642, - 0, 0, 0, 0, 0, 2198, 0, 0, 0, 1639, - 0, 0, 1640, 0, 0, 2102, 1641, 1642, 1643, 1644, - 1645, 1646, 1647, 2102, 0, 0, 0, 0, 0, 1650, - 0, 0, 0, 0, 0, 0, -2102, 1648, 0, 1609, - 1610, 0, 0, 0, 0, 0, 0, 1650, 0, 0, - 0, 0, 0, 0, 1651, 0, 0, 0, 808, 0, - 0, 0, 0, 1652, 0, 0, 0, 1440, 0, 0, - 0, 1638, 0, 0, 0, 0, 1639, 0, 0, 1640, - 0, 1652, 0, 1641, 1642, 1643, 1644, 1645, 1646, 1647, - 0, 1639, 0, 0, 1640, 0, 0, 0, 1641, 1642, - 0, 0, 0, 0, 1648, 0, 0, 0, 1649, 0, - 0, 0, 0, 0, 1650, 0, 558, 0, 0, 0, - 0, 1651, 0, 0, 0, 0, 0, 0, 2865, 1650, - 2324, 0, 0, 0, 0, 1302, -2102, 0, 2334, 2335, - 0, 0, 0, 1639, 0, 0, 1640, 0, 1652, 0, - 1641, 1642, 1643, 1644, 1645, 1646, 1647, 0, 0, 0, - -2102, 0, 0, 1652, 0, 0, 0, 0, 0, 0, - 0, 1648, 0, 0, 0, 2845, 0, -2102, 1653, 1302, - 0, 1650, -2102, 0, 0, 0, 0, 0, 1651, 0, - 0, 0, 0, 0, 0, 1654, 0, 0, 0, 0, - 1655, 0, 0, 0, 1359, 2401, 0, 0, 0, 0, - 1440, 0, 0, 0, 1639, 1652, 0, 1640, 0, 0, - -2102, 1641, 1642, 1656, 1657, 1645, 1646, 1647, 2868, 3370, - 0, 0, 0, 2427, 2428, 0, 2429, 0, 1658, 0, - 0, 0, 1648, 0, 0, 1653, 0, 0, 0, 0, - 3394, 0, 1650, 0, 0, 0, 0, 0, 0, 1651, - -2102, 0, 1654, 0, 0, 2455, 2456, 1655, 0, 2198, - 0, 0, 0, 0, 0, 1661, 1659, -2102, 0, 1660, - 0, 0, -2102, 0, 0, 0, 1652, 0, 0, 0, - 1656, 1657, 3302, 1661, 0, 0, 1662, 0, 0, 2493, - 2481, 0, 0, 0, 0, 1658, 0, 2487, 0, 0, - 0, 0, 1653, 0, 1639, 3434, 0, 1640, 0, 0, - -2102, 1641, 1642, 0, 0, 1498, 0, 1302, 0, 1654, - 0, 0, 0, 0, 1655, 0, 0, 0, 0, 0, - 0, 0, 0, 1659, 0, 3460, 1660, 1441, 0, 0, - 0, 0, 1650, 0, 0, 0, 0, 1656, 1657, -2102, - 1661, 0, 558, 1662, 0, 2522, 0, 558, 0, 0, - 0, 0, 1658, 0, 0, 1661, 0, -2102, 0, 0, - 0, 0, 0, 1653, 0, 0, 1652, 0, 0, 0, - 0, 0, 0, 558, 0, 1663, 0, 0, 0, 0, - 1654, 0, 2539, 0, 0, 1655, 2545, 0, 0, 0, - 1659, 2553, 2554, 1660, 0, 558, 558, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1440, 1661, 1656, 1657, - 1662, 0, 0, 0, 0, 0, 0, 0, 0, 558, + 2458, 2459, 0, 1661, 2200, 0, 1662, 0, 1656, 1657, + -2102, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1658, 0, 0, 0, 0, 0, 0, - 0, 2869, 0, 0, 0, 0, 0, 0, 2575, 0, - 0, 2578, 1663, 2580, 0, 0, 0, 0, 0, 0, - 0, 1676, 0, 0, 0, 0, 0, -2102, 0, 2584, - 558, 1659, 0, -2102, 1660, -2102, 0, 0, 2102, 0, - 0, 0, 1668, 1669, 1670, 1671, 1672, 1673, 1661, 0, - -2102, 1662, 0, 1664, 0, -2102, 1665, 1666, 1667, 0, - 1668, 1669, 1670, 1671, 1672, 1673, 0, 0, 0, 1720, - 1676, 0, 0, 1932, 0, 0, 0, 0, 0, 1663, - 0, 0, 0, 0, 0, 0, 1741, 2170, 0, 0, - 0, 0, 0, -2102, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1441, 1121, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 2640, 0, - 1664, 0, 0, 1665, 1666, 1667, 0, 1668, 1669, 1670, - 1671, 1672, 1673, 0, 0, -2102, 0, 0, 0, 0, - 0, 0, 1668, 1669, 1670, 1671, 1672, 1673, 1661, 0, - 1663, 0, 0, 0, 0, 0, 0, 0, 0, 1676, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1610, 0, 0, 0, 0, - 0, 1302, 0, 0, 0, 0, 0, 1664, 0, 0, - 1665, 1666, 1667, 0, 1668, 1669, 1670, 1671, 1672, 1673, - 0, 0, 1676, 0, 2108, 0, 0, 0, 0, 1676, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 558, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 2484, 0, 0, 0, 0, + 0, 0, 2490, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1653, 0, 0, 0, 0, 0, 0, + 1498, 1659, 1302, 0, 1660, 0, 0, 0, 0, 0, + 1654, 0, 0, 0, 0, 1655, 0, 0, 1661, 0, + 3303, 0, 0, 0, 0, 0, 0, 2496, 0, 0, + 0, 0, 0, 0, 0, 0, 1676, 0, 1656, 1657, + 2525, 0, 0, 0, 0, 1663, 0, 0, 0, 0, + 0, 0, 0, 1658, 0, 0, 0, 0, -2102, 0, + 0, 0, 0, 0, 0, 1668, 1669, 1670, 1671, 1672, + 1673, 0, 0, 0, 0, 0, 0, 2542, 0, 0, + 0, 2548, 0, 0, 0, 1676, 2556, 2557, 0, 0, + 558, 1659, 0, 0, 1660, 558, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1661, 0, + 0, 1662, 0, 0, 0, 0, 0, 0, 0, 1441, + 1663, 558, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2578, 0, 0, 2581, 0, 2583, 0, + 0, 0, 0, 558, 558, 0, 0, 0, 0, 0, + 0, 0, 0, 1664, 2587, 0, 1665, 1666, 1667, 0, + 1668, 1669, 1670, 1671, 1672, 1673, 0, 558, 0, 0, + 0, 0, 0, 1934, 1676, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 2752, 0, 1639, 0, 0, 1640, 0, 0, - -2102, 1641, 1642, 1643, 1644, 1645, 1646, 1647, 1664, 1676, + 0, 0, 0, 0, 1720, 0, 1639, 0, 0, 1640, + 0, 0, 0, 1641, 1642, 0, 0, 0, 558, 0, + 1663, 1741, 2172, 0, 0, 0, 2104, 1676, 0, 0, + 0, 0, 0, 0, 1676, 0, 0, 0, 1664, 0, + 1121, 1665, 1666, 1667, 1650, 1668, 1669, 1670, 1671, 1672, + 1673, -2102, 0, 2643, 0, 1639, 0, 0, 1640, 0, + 0, 0, 1641, 1642, 1643, 1644, 1645, 1646, 1647, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1652, 0, + 0, 0, 0, 1648, 1676, 0, 0, 2846, 0, 0, + 0, 0, 0, 1650, 0, 0, 0, 0, 0, 0, + 1651, 0, 0, 0, 0, 0, 0, 0, 1676, 0, + 1610, 0, 0, 0, 0, 0, 0, 0, 0, 1302, + 0, 0, 0, 0, 0, 0, 0, 1652, 1664, 0, 0, 1665, 1666, 1667, 0, 1668, 1669, 1670, 1671, 1672, - 1673, 0, 1648, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1650, 1676, 0, 0, 0, 0, 0, 1651, - 0, 0, 1639, 0, 0, 1640, 0, 0, 0, 1641, - 1642, 1643, 1644, 1645, 1646, 1647, 0, 0, 0, 0, - 0, 1639, 0, 0, 1640, 0, 1652, 0, 1641, 1642, - 1648, 0, 1645, 1646, 1647, 0, 0, 0, 0, 0, - 1650, 1676, 0, 1676, 0, 1441, 1441, 1651, 1957, 1648, - 0, 1441, 0, 0, 1676, 0, 0, 1676, 0, 1650, - 0, 0, 1676, 0, 0, 1676, 1651, 0, -2102, 0, - 0, 0, 0, 0, 1652, 1668, 1669, 1670, 1671, 1672, - 1673, 0, 0, 0, 0, 2830, 0, 0, 0, 0, - 0, 2832, 2069, 1652, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 2841, 0, 1676, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 2854, 1653, 0, 2857, 0, 2859, 0, 0, - 0, 0, 0, 0, 0, 2863, 0, 0, 0, 0, - 1654, 0, 0, 2870, 2871, 1655, 0, 0, 0, 0, - 2878, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 2887, 0, 0, 1656, 1657, - 0, 1653, 0, 0, 0, 2902, 0, 0, 0, 0, - 0, 0, 0, 1658, 0, 0, 0, 0, 1654, 0, - 1653, 0, 1676, 1655, 0, 1121, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1654, 1676, 0, - 0, 0, 1655, 0, 0, 0, 1656, 1657, 1676, 1676, - 1676, 1659, 0, 0, 1660, 1676, 0, 0, 0, 1676, - 0, 1658, 0, 0, 0, 1656, 1657, 0, 1661, 0, - 0, 1662, 0, 0, 0, 722, 0, 0, 0, 0, - 1658, 0, 0, 0, 2324, 0, 2324, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1659, - 0, 0, 1660, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1661, 0, 1659, 1662, - 0, 1660, 1676, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 723, 0, 0, 1661, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 724, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1673, 0, 0, 3155, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1676, 0, 1676, 0, + 1441, 1441, 0, 1959, 0, 0, 1441, 0, 0, 1676, + 0, 0, 1676, 0, 0, -2102, 0, 1676, 2753, 0, 1676, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1663, 0, 0, 0, 0, 0, 1676, 0, 0, 0, - 0, 1676, 0, 0, 0, 0, 3107, 3108, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 725, 1957, 0, - 0, 0, 0, 0, 0, 0, 0, 726, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1663, 0, - 727, 3131, 0, 0, 0, 728, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1663, 0, 0, - 0, 3140, 0, 0, 0, 0, 0, 3144, 3145, 0, - 0, 0, 3146, 0, 729, 0, 0, 3149, 0, 0, - 3152, 3153, 0, 0, 0, 2324, 1302, 1639, 0, 3161, - 1640, 0, 0, 0, 1641, 1642, 0, 0, 1664, 0, - 1121, 1665, 1666, 1667, 0, 1668, 1669, 1670, 1671, 1672, - 1673, 0, 0, 0, 0, 2108, 0, 730, 0, 0, - 0, 731, 0, 0, 0, 1650, 0, 0, 0, 0, - 0, 0, -2102, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 3202, 0, 1664, 0, 0, 1665, - 1666, 1667, 0, 1668, 1669, 1670, 1671, 1672, 1673, 1652, - 0, 0, 0, 2426, 0, 1664, 0, 0, 1665, 1666, - 1667, 3221, 1668, 1669, 1670, 1671, 1672, 1673, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1676, - 0, 732, 0, 0, 0, 0, 0, 1957, 1957, 0, - 1441, 1441, 1441, 1441, 1441, 1441, 733, 0, 1441, 1441, - 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1441, 1957, 0, - 0, 0, 0, 1639, 3154, 0, 1640, 0, 0, 0, - 1641, 1642, 1643, 1644, 1645, 1646, 1647, 0, 0, 0, - 0, 734, 0, 0, 735, 0, 0, 0, 0, 0, - 0, 1648, 0, 0, 0, 736, -2102, 0, 737, 0, - 0, 1650, 0, 0, 0, 0, 0, 0, 1651, 0, - 0, 0, 0, -2102, 0, 0, 738, 0, -2102, 0, - 0, 0, 0, 0, 2752, 0, 0, 0, 0, 0, - 739, 0, 0, 0, 0, 1652, 0, 741, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 742, 0, 0, - 0, 1619, 0, 743, 0, 0, -2102, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1676, 0, 0, 1676, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 744, 0, 0, 0, 2545, 0, 0, 0, 0, + 0, 0, -2102, 0, 0, 0, 0, -2102, 0, 0, + 0, 0, 0, 0, 1639, 0, 0, 1640, 0, 558, + 0, 1641, 1642, 1643, 1644, 1645, 1646, 1647, 0, 0, + 0, 0, 0, 1676, 1653, 0, 0, 0, 0, 0, + 0, 0, 1648, 0, 0, -2102, 0, 0, 0, 0, + 0, 1654, 1650, 0, 0, 0, 1655, 0, 0, 1651, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 3317, 3318, 0, 0, 3319, 0, 1610, 0, - 0, 1661, 0, 0, 1676, 0, 0, 0, 1676, 0, - 0, 0, 1676, 1676, 1676, 1676, 1676, 1676, 1676, 1676, - 0, 0, 1653, 3337, 0, 1441, 1441, 0, 1676, 1676, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1654, - 0, 0, 1676, 0, 1655, 1676, 0, 3349, 0, 0, - 0, 0, 0, 1676, 1676, 1676, 1676, 1676, 1676, 1676, - 1676, 1676, 1676, 0, 0, 0, 0, 1656, 1657, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1656, + 1657, 0, 0, 0, 0, 0, 1652, 0, 0, 0, + 0, 0, 0, 0, 1658, 0, 0, 0, 0, 0, + 1661, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1676, 0, 0, + 0, 2831, 0, 0, 0, 0, 0, 2833, 2071, 0, + 0, 0, 1659, 1676, 0, 1660, 0, 0, 0, 0, + 0, 0, 2842, 1676, 1676, 1676, 0, 0, 0, 1661, + 1676, 0, 1662, 0, 1676, 0, 0, 0, 2855, 0, + 0, 2858, 0, 2860, 0, 0, 0, 0, 0, 0, + 0, 2864, 0, 0, 0, 0, 0, 0, 0, 2871, + 2872, 0, 0, 1653, 0, 0, 2879, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1658, 0, 0, 0, 0, 0, 1676, 0, + 1654, 2888, -2102, 0, 0, 1655, 0, 0, 0, 0, + 0, 2903, 0, 0, 0, 0, 0, 1676, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1656, 1657, + 0, 1121, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1658, 0, 0, 0, 0, 0, 0, + 0, 1663, 0, 0, 0, 1676, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, -2102, 0, 0, 0, 0, 0, 0, + 0, 1676, 0, 0, 0, 0, 1676, 0, 0, 0, + 0, 1659, 0, 0, 1660, 0, 0, 0, 0, 0, + 2326, 0, 2326, 1959, 0, 0, 0, 0, 1661, 0, + 0, 1662, 0, 0, 0, 0, 0, 0, 0, 0, + -2102, 0, 0, 0, 0, 0, 0, 1668, 1669, 1670, + 1671, 1672, 1673, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1659, 0, 0, 1660, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 3107, 0, 1661, 0, 3410, - 1662, 1441, 0, 1121, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 3420, 0, 0, - 0, 0, 2324, 0, 2324, 0, 0, 0, 0, 0, - 0, 0, 1121, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 3445, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1664, + 0, 0, 1665, 1666, 1667, 0, 1668, 1669, 1670, 1671, + 1672, 1673, 0, 0, 0, 0, 2110, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, -2102, 0, 0, 1676, 0, 0, 0, 1668, 1669, - 1670, 1671, 1672, 1673, 1676, 1676, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 3470, 0, 1663, - 0, 0, 0, 0, 0, 0, 0, 3107, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1121, + 3108, 3109, 0, 0, 0, 0, 0, 0, 0, 0, + 1663, 0, 0, 0, 1639, 0, 0, 1640, 0, 0, + 0, 1641, 1642, 1643, 1644, 1645, 1646, 1647, 0, 0, + 0, 0, 0, 0, 0, 3132, 0, 0, 0, 0, + 0, 0, 1648, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1650, 0, 0, 3141, 0, 0, 0, 1651, + 0, 3145, 3146, 0, 0, 0, 3147, 0, 0, 0, + 0, 3150, 0, 0, 3153, 3154, 1676, 0, 0, 2326, + 1302, 0, 0, 3162, 1959, 1959, 1652, 1441, 1441, 1441, + 1441, 1441, 1441, 0, 1121, 1441, 1441, 1441, 1441, 1441, + 1441, 1441, 1441, 1441, 1441, 1959, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1664, 0, + 0, 1665, 1666, 1667, 0, 1668, 1669, 1670, 1671, 1672, + 1673, 0, 0, 0, 0, 2110, 1387, 1388, 3203, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1639, 0, 0, 1640, 3222, 0, 0, 1641, 1642, + 1643, 1644, 1645, 1646, 1647, 0, 0, 1389, 1390, 0, + 0, 1391, 1392, 1653, 0, 0, 0, 0, 0, 1648, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1650, + 1654, 0, 0, 0, 0, 1655, 1651, 0, 0, 0, + 0, 0, 0, 1676, 0, 0, 1676, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1656, 1657, + 0, 0, 0, 1652, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1658, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1393, 1394, 0, + 0, 1676, 0, 0, 0, 1676, 0, 0, 0, 1676, + 1676, 1676, 1676, 1676, 1676, 1676, 1676, 0, 2753, 0, + 0, 1659, 1441, 1441, 1660, 1676, 1676, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1661, 1676, + 0, 1662, 1676, 0, 0, 1619, 0, 0, 0, 0, + 1676, 1676, 1676, 1676, 1676, 1676, 1676, 1676, 1676, 1676, + 0, 1395, 1396, 1397, 1398, 1399, 1400, 1401, 1402, 0, + 1653, 1403, 1404, 0, 0, 0, 0, 0, 0, 2548, + 0, 0, 0, 0, 0, 1676, 0, 1654, 0, 0, + 0, 0, 1655, 0, 0, 0, 3318, 3319, 0, 0, + 3320, 0, 1610, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1656, 1657, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3338, 0, 0, + 1658, 0, 0, 0, 0, 0, 0, 0, 1441, 0, + 1663, 0, 0, 0, 0, 1405, 1406, 0, 0, 0, + 0, 3350, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1659, 0, + 0, 1660, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1661, 1407, 1408, 1662, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1676, 3513, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1676, 1676, 1676, - 0, 0, 1957, 1957, 1957, 1957, 1957, 1957, 0, 0, - 0, 1957, 1957, 1957, 1957, 1957, 1957, 1957, 1957, 1957, - 1957, 0, 0, 0, 0, 1676, 1676, 1664, 0, 0, - 1665, 1666, 1667, 0, 1668, 1669, 1670, 1671, 1672, 1673, - 0, 0, 0, 0, 2526, 0, 0, 0, 0, 0, - 0, 1676, 0, 0, 0, 0, 0, 1676, 0, 3567, - 3567, 3567, 0, 1639, 0, 0, 1640, 0, 0, 0, - 1641, 1642, 1643, 1644, 1645, 1646, 1647, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 3567, 0, 0, 0, - 0, 1648, 1676, 0, 0, 0, 0, 0, 0, 0, - 0, 1650, 0, 0, 0, 0, 0, 0, 1651, 1676, - 0, 0, 0, 0, 0, 1676, 0, 0, 0, 0, - 0, 0, 0, 1676, 1676, 0, 0, 3567, 0, 0, - 0, 1957, 1957, 0, 0, 1652, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1676, 1441, 1441, 1676, 0, - 1676, 0, 0, 0, 1676, 0, 0, 0, 0, 0, + 0, 1676, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1676, 1676, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 3108, + 0, 0, 0, 3411, 0, 0, 0, 1121, 1664, 0, + 0, 1665, 1666, 1667, 0, 1668, 1669, 1670, 1671, 1672, + 1673, 3421, 0, 0, 0, 2429, 2326, 0, 2326, 0, + 0, 0, 0, 0, 0, 0, 1121, 0, 0, 0, + 0, 0, 1409, 1410, 0, 0, 0, 1663, 0, 1676, + 0, 0, 0, 0, 3446, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1411, 1412, 0, 0, + 0, 0, 0, 0, 0, 1676, 1676, 1676, 0, 0, + 1959, 1959, 1959, 1959, 1959, 1959, 2036, 0, 0, 1959, + 1959, 1959, 1959, 1959, 1959, 1959, 1959, 1959, 1959, 0, + 0, 3471, 0, 1676, 1676, 1639, 0, 0, 1640, 0, + 0, 3108, 1641, 1642, 1643, 1644, 1645, 1646, 1647, 0, + 0, 0, 0, 1121, 0, 0, 0, 0, 0, 1676, + 0, 0, 0, 1648, 0, 1676, 0, 0, 0, 0, + 0, 0, 0, 1650, 0, 0, 0, 0, 0, 0, + 1651, 0, 0, 0, 0, 1664, 3514, 0, 1665, 1666, + 1667, 0, 1668, 1669, 1670, 1671, 1672, 1673, 0, 0, + 1676, 0, 2529, 0, 0, 0, 0, 1652, 0, 0, + 0, 0, 0, 722, 0, 0, 0, 1676, 0, 0, + 0, 0, 0, 1676, 0, 0, 0, 0, 0, 0, + 0, 1676, 1676, 0, 0, 0, 0, 0, 0, 1959, + 1959, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1676, 1441, 1441, 1676, 0, 1676, 0, + 0, 0, 1676, 0, 0, 0, 0, 0, 0, 0, + 723, 0, 0, 3568, 3568, 3568, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 724, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1639, + 3568, 0, 1640, 0, 1653, 0, 1641, 1642, 1643, 1644, + 1645, 1646, 1647, 0, 0, 0, 0, 0, 1676, 0, + 0, 1654, 0, 0, 0, 0, 1655, 1648, 0, 0, + 0, 0, 0, 0, 0, 725, 0, 1650, 0, 0, + 0, 3568, 0, 0, 1651, 726, 0, 0, 0, 1656, + 1657, 0, 0, 0, 0, 0, 0, 0, 727, 0, + 0, 0, 0, 728, 1658, 0, 0, 0, 0, 0, + 0, 1652, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1639, 0, - 0, 1640, 0, 0, 0, 1641, 1642, 1643, 1644, 1645, - 1646, 1647, 0, 0, 0, 0, 0, 0, 0, 1387, - 1388, 0, 0, 0, 0, 0, 1648, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1650, 0, 0, 0, - 1676, 0, 0, 1651, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1389, 1390, 1653, 0, 1391, 1392, 0, 0, 0, 0, - 1652, 0, 0, 0, 0, 0, 0, 0, 1639, 1654, - 0, 1640, 0, 0, 1655, 1641, 1642, 1643, 1644, 1645, - 1646, 1647, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1648, 1656, 1657, 0, - 0, 0, 0, 0, 0, 0, 1650, 0, 0, 0, - 0, 0, 1658, 1651, 0, 0, 0, 0, 0, 0, + 0, 1640, 729, 0, 0, 1641, 1642, 1643, 1644, 1645, + 1646, 1647, 1659, 0, 0, 1660, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1648, 0, 0, 1661, + 0, 0, 1662, 0, 0, 0, 1650, 0, 1676, 0, + 0, 0, 0, 1651, 0, 730, 0, 0, 0, 731, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1393, 1394, 0, 0, 0, 0, 0, 0, 0, 0, - 1652, 0, 1676, 0, 0, 0, 0, 0, 0, 0, - 1659, 0, 0, 1660, 0, 0, 0, 1653, 0, 0, - 0, 0, 0, 0, 1441, 0, 0, 1661, 0, 0, - 1662, 0, 0, 0, 1654, 0, 0, 0, 1639, 1655, - 0, 1640, 0, 0, 0, 1641, 1642, 1643, 1644, 1645, - 1646, 1647, 0, 0, 1395, 1396, 1397, 1398, 1399, 1400, - 1401, 1402, 1656, 1657, 1403, 1404, 1648, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1650, 1658, 0, 0, - 1676, 0, 1676, 1651, 0, 0, 0, 0, 0, 0, - 0, 1676, 0, 0, 0, 0, 0, 1653, 0, 1387, - 1388, 0, 0, 0, 1676, 0, 0, 1676, 0, 1676, - 1652, 0, 0, 1676, 1654, 1659, 1957, 1957, 1660, 1655, - 1676, 1676, 0, 0, 0, 0, 0, 0, 1676, 1663, - 0, 0, 1661, 0, 0, 1662, 0, 1676, 1405, 1406, - 1389, 1390, 1656, 1657, 1391, 1392, 0, 0, 0, 0, - 0, 0, 1676, 0, 0, 0, 0, 1658, 0, 0, + 1441, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1652, 0, 0, 0, 0, 0, 1639, 0, 1653, 1640, + 0, 0, 0, 1641, 1642, 1643, 1644, 1645, 1646, 1647, + 0, 0, 0, 0, 0, 1654, 0, 0, 0, 0, + 1655, 0, 0, 0, 1648, 0, 0, 0, 0, 0, + 0, 0, 0, 544, 1650, 0, 1676, 0, 1676, 732, + 0, 1651, 0, 1656, 1657, 0, 0, 1676, 0, 0, + 0, 1663, 0, 0, 733, 0, 0, 0, 1658, 0, + 1676, 0, 0, 1676, 0, 1676, 0, 0, 1652, 1676, + 0, 0, 1959, 1959, 0, 0, 1676, 1676, 0, 0, + 0, 0, 0, 0, 1676, 0, 0, 1653, 0, 734, + 0, 0, 735, 1676, 0, 0, 1659, 0, 0, 1660, + 0, 0, 0, 736, 1654, 0, 737, 0, 1676, 1655, + 0, 0, 0, 1661, 0, 0, 1662, 0, 0, 0, + 0, 0, 0, 0, 738, 0, 0, 0, 0, 0, + 0, 0, 1656, 1657, 0, 0, 0, 0, 739, 0, + 0, 0, 0, 0, 740, 741, 1441, 1658, 0, 0, + 0, 0, 0, 0, 0, 742, 0, 0, 0, 1664, + 0, 743, 1665, 1666, 1667, 1653, 1668, 1669, 1670, 1671, + 1672, 1673, 0, 0, 0, 0, 2562, 0, 0, 0, + 0, 0, 1654, 0, 0, 1659, 0, 1655, 1660, 744, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1407, - 1408, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1441, 0, 0, 0, 0, 1659, 0, 0, 1660, 0, - 0, 0, 0, 0, 0, 0, 0, 1653, 0, 0, - 0, 0, 1661, 0, 0, 1662, 0, 0, 0, 0, - 1393, 1394, 0, 0, 1654, 0, 0, 0, 0, 1655, - 0, 0, 0, 0, 1663, 0, 0, 1664, 0, 0, - 1665, 1666, 1667, 0, 1668, 1669, 1670, 1671, 1672, 1673, - 0, 0, 1656, 1657, 2559, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1658, 0, 0, - 0, 0, 0, 0, 0, 1409, 1410, 0, 0, 0, - 0, 0, 0, 0, 1395, 1396, 1397, 1398, 1399, 1400, - 1401, 1402, 0, 0, 1403, 1404, 0, 0, 0, 1411, - 1412, 0, 0, 0, 0, 1659, 0, 0, 1660, 0, - 0, 0, 0, 0, 1663, 0, 0, 0, 0, 2034, - 0, 0, 1661, 0, 0, 1662, 0, 0, 0, 0, - 0, 0, 1957, 1441, 0, 0, 0, 0, 0, 0, - 0, 0, 1664, 0, 0, 1665, 1666, 1667, 0, 1668, - 1669, 1670, 1671, 1672, 1673, 0, 0, 1676, 1676, 2772, - 0, 0, 0, 0, 0, 0, 0, 0, 1405, 1406, + 1387, 1388, 1661, 0, 0, 1662, 0, 0, 0, 0, + 1656, 1657, 0, 0, 0, 1663, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1658, 0, 0, 0, 0, + 0, 0, 0, 0, 722, 0, 0, 0, 0, 0, + 0, 1389, 1390, 0, 0, 1391, 1392, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1676, 0, 0, 0, 0, 0, 0, 0, 0, - 1676, 0, 0, 0, 1676, 1676, 1676, 0, 0, 1676, - 0, 0, 1676, 1676, 0, 0, 0, 0, 0, 1407, - 1408, 1676, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1664, 0, 1663, 1665, 1666, 1667, 0, 1668, - 1669, 1670, 1671, 1672, 1673, 0, 0, 0, 0, 2837, + 0, 0, 0, 1659, 0, 0, 1660, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1676, 0, 0, 0, 0, 0, 1957, 0, + 1661, 0, 0, 1662, 0, 0, 0, 0, 1959, 1441, + 0, 723, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1663, 0, 0, 724, 0, 0, + 0, 0, 0, 1676, 1676, 0, 0, 0, 0, 0, + 0, 1393, 1394, 1664, 0, 0, 1665, 1666, 1667, 0, + 1668, 1669, 1670, 1671, 1672, 1673, 0, 1676, 0, 0, + 2773, 0, 0, 0, 0, 0, 1676, 0, 0, 0, + 1676, 1676, 1676, 0, 0, 1676, 725, 0, 1676, 1676, + 0, 0, 0, 0, 0, 0, 726, 1676, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 727, + 0, 0, 1663, 0, 728, 1395, 1396, 1397, 1398, 1399, + 1400, 1401, 1402, 0, 0, 1403, 1404, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1676, 0, + 0, 0, 1664, 729, 1959, 1665, 1666, 1667, 0, 1668, + 1669, 1670, 1671, 1672, 1673, 0, 0, 1676, 0, 2838, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1676, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 730, 0, 0, 0, + 731, 0, 0, 0, 0, 0, 0, 0, 0, 1405, + 1406, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1959, 0, 0, + 1664, 0, 0, 1665, 1666, 1667, 0, 1668, 1669, 1670, + 1671, 1672, 1673, 0, 0, 0, 0, 2852, 0, 0, + 1407, 1408, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1676, 1676, 1676, 0, 0, 0, 0, + 732, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1676, 0, 733, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1676, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1409, 1410, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1411, - 1412, 1957, 1664, 0, 0, 1665, 1666, 1667, 0, 1668, - 1669, 1670, 1671, 1672, 1673, 0, 0, 0, 0, 2851, + 734, 0, 0, 735, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 736, 0, 0, 737, 0, 0, + 0, 0, 0, 0, 0, 0, 1409, 1410, 0, 0, + 0, 0, 0, 0, 0, 738, 1676, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1676, 0, 0, 739, + 1411, 1412, 0, 0, 0, 0, 741, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 742, 0, 0, 0, + 0, 1676, 743, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1676, 1676, 1676, + 0, 0, 0, 0, 0, 0, 1676, 0, 0, 0, + 744, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1676, 0, 0, + 0, 0, 117, 1056, 821, 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1676, + 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, + 126, 127, 128, 0, 0, 0, 0, 0, 1062, 0, + 0, 129, 130, 131, 0, 132, 133, 134, 135, 136, + 137, 138, 139, 1063, 141, 1064, 1065, 0, 144, 145, + 146, 147, 148, 149, 1066, 790, 150, 151, 152, 153, + 1067, 1068, 156, 1676, 157, 158, 159, 160, 791, 0, + 792, 0, 1069, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 1070, 191, 192, 1071, 194, 1072, 195, 0, 196, + 197, 198, 199, 200, 201, 14, 15, 202, 203, 204, + 205, 0, 0, 206, 207, 1073, 209, 210, 0, 211, + 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, + 220, 1074, 222, 223, 224, 225, 226, 227, 793, 1075, + 229, 0, 230, 231, 1076, 233, 0, 234, 0, 235, + 236, 23, 237, 238, 239, 240, 241, 242, 0, 243, + 0, 1077, 1078, 246, 247, 0, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 0, 0, 289, 290, 291, 292, 0, 293, 294, + 295, 296, 297, 298, 299, 300, 1082, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 1083, 323, 1084, + 325, 326, 327, 328, 1085, 329, 330, 331, 332, 1086, + 795, 334, 1087, 336, 337, 338, 0, 339, 340, 0, + 0, 1088, 342, 343, 0, 0, 344, 345, 346, 347, + 348, 349, 797, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 26, 27, 28, 0, 362, 363, + 798, 365, 366, 367, 368, 369, 370, 371, 0, 372, + 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, + 382, 1089, 384, 385, 386, 387, 0, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 0, 401, 402, 403, 404, 405, 406, 1090, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 33, 0, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 35, 430, 431, 432, 1091, 434, 0, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, 447, 448, 800, 37, 0, 450, 451, 38, 452, + 453, 454, 455, 456, 457, 458, 0, 459, 1092, 1093, + 0, 0, 462, 463, 801, 465, 802, 1094, 467, 468, + 803, 470, 471, 472, 473, 474, 0, 0, 475, 476, + 477, 40, 478, 479, 480, 481, 0, 482, 483, 484, + 485, 486, 804, 1095, 489, 0, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 0, 0, 499, 0, 44, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, + 520, 1096, 0, 45, 0, 0, 0, 0, 1097, 1098, + 1099, 0, 0, 0, 0, 1100, 0, 1101, 3293, 0, + 0, 0, 0, 1102, 1103, 1104, 1105, 117, 1056, 821, + 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, + 0, 0, 0, 1062, 0, 0, 129, 130, 131, 0, + 132, 133, 134, 135, 136, 137, 138, 139, 1063, 141, + 1064, 1065, 0, 144, 145, 146, 147, 148, 149, 1066, + 790, 150, 151, 152, 153, 1067, 1068, 156, 0, 157, + 158, 159, 160, 791, 0, 792, 0, 1069, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 1070, 191, 192, 1071, + 194, 1072, 195, 0, 196, 197, 198, 199, 200, 201, + 14, 15, 202, 203, 204, 205, 0, 0, 206, 207, + 1073, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 1074, 222, 223, 224, + 225, 226, 227, 793, 1075, 229, 0, 230, 231, 1076, + 233, 0, 234, 0, 235, 236, 23, 237, 238, 239, + 240, 241, 242, 0, 243, 0, 1077, 1078, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, + 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 1079, 1080, 0, 1081, 0, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 290, + 291, 292, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 1082, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 1083, 323, 1084, 325, 326, 327, 328, 1085, + 329, 330, 331, 332, 1086, 795, 334, 1087, 336, 337, + 338, 0, 339, 340, 0, 0, 1088, 342, 343, 0, + 0, 344, 345, 346, 347, 348, 349, 797, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 26, + 27, 28, 0, 362, 363, 798, 365, 366, 367, 368, + 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, + 0, 378, 379, 380, 381, 382, 1089, 384, 385, 386, + 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 0, 401, 402, 403, 404, + 405, 406, 1090, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 33, 0, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 35, 430, 431, + 432, 1091, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 447, 448, 800, 37, + 0, 450, 451, 38, 452, 453, 454, 455, 456, 457, + 458, 0, 459, 1092, 1093, 0, 0, 462, 463, 801, + 465, 802, 1094, 467, 468, 803, 470, 471, 472, 473, + 474, 0, 0, 475, 476, 477, 40, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 804, 1095, 489, + 0, 490, 491, 492, 493, 494, 495, 496, 497, 498, + 0, 0, 499, 0, 44, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 520, 1096, 0, 45, 0, + 0, 0, 0, 1097, 1098, 1099, 0, 0, 0, 0, + 1100, 0, 1101, 0, 0, 0, 0, 0, 1102, 1103, + 1104, 1105, 117, 1056, 821, 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, + 126, 127, 128, 0, 0, 0, 0, 0, 1062, 0, + 0, 129, 130, 131, 0, 132, 133, 134, 135, 136, + 137, 138, 139, 1063, 141, 1064, 1065, 0, 144, 145, + 146, 147, 148, 149, 1066, 790, 150, 151, 152, 153, + 1067, 1068, 156, 0, 157, 158, 159, 160, 791, 0, + 792, 0, 1069, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 1070, 191, 192, 1071, 194, 1072, 195, 0, 196, + 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, + 205, 0, 0, 206, 207, 1073, 209, 210, 0, 211, + 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, + 220, 1074, 222, 223, 224, 225, 226, 227, 793, 1075, + 229, 0, 230, 231, 1076, 233, 0, 234, 0, 235, + 236, 23, 237, 238, 239, 240, 241, 242, 0, 243, + 0, 1077, 1078, 246, 247, 0, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 0, 0, 289, 290, 291, 292, 0, 293, 294, + 295, 296, 297, 298, 299, 300, 1082, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 1083, 323, 1084, + 325, 326, 327, 328, 1085, 329, 330, 331, 332, 1086, + 795, 334, 1087, 336, 337, 338, 0, 339, 340, 0, + 0, 1088, 342, 343, 0, 0, 344, 345, 346, 347, + 348, 349, 797, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 26, 27, 28, 0, 362, 363, + 798, 365, 366, 367, 368, 369, 370, 371, 0, 372, + 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, + 382, 1089, 384, 385, 386, 387, 0, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 0, 401, 402, 403, 404, 405, 406, 1090, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 33, 0, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 0, 430, 431, 432, 1091, 434, 0, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, 447, 448, 800, 0, 0, 450, 451, 38, 452, + 453, 454, 455, 456, 457, 458, 0, 459, 1092, 1093, + 0, 0, 462, 463, 801, 465, 802, 1094, 467, 468, + 803, 470, 471, 472, 473, 474, 0, 0, 475, 476, + 477, 40, 478, 479, 480, 481, 0, 482, 483, 484, + 485, 486, 804, 1095, 489, 0, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 0, 0, 499, 0, 44, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, + 520, 1096, 0, 45, 0, 0, 0, 0, 1097, 1098, + 1099, 0, 0, 0, 0, 1100, 0, 1101, 0, 0, + 0, 0, 0, 1102, 1103, 1104, 1105, 1264, 1056, 821, + 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 1265, 126, 127, 128, 0, 0, + 0, 1266, 0, 1062, 0, 0, 1267, 130, 131, 0, + 132, 133, 134, 1268, 136, 137, 138, 139, 1063, 1269, + 1064, 1065, 0, 144, 145, 146, 147, 148, 149, 1066, + 790, 150, 151, 152, 153, 1067, 1068, 156, 0, 157, + 158, 159, 160, 791, 0, 1270, 0, 1271, 164, 165, + 166, 167, 168, 1272, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 1273, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 1070, 191, 192, 1071, + 194, 1072, 195, 0, 196, 197, 198, 199, 200, 201, + 0, 0, 202, 203, 204, 205, 1274, 0, 206, 207, + 1073, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 1074, 222, 223, 224, + 225, 226, 227, 793, 1075, 229, 0, 230, 231, 1076, + 233, 0, 234, 0, 235, 1275, 0, 1276, 238, 239, + 1277, 1278, 242, 0, 243, 0, 1077, 1078, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 1279, 256, + 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, + 266, 0, 267, 1280, 269, 270, 271, 272, 273, 274, + 1079, 1080, 0, 1081, 0, 278, 1281, 1282, 281, 1283, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 1284, + 291, 1285, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 1286, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 1083, 1287, 1084, 325, 326, 327, 328, 1085, + 329, 330, 1288, 332, 1086, 795, 334, 1087, 336, 337, + 338, 0, 339, 340, 0, 0, 1088, 342, 343, 0, + 881, 344, 345, 346, 1289, 348, 1290, 797, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, + 0, 0, 0, 362, 363, 798, 1291, 366, 367, 368, + 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, + 0, 378, 379, 380, 381, 382, 1089, 384, 385, 386, + 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 0, 401, 402, 1292, 404, + 405, 406, 1090, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 0, 1293, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 0, 1294, 431, + 432, 1091, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 1295, 448, 800, 0, + 0, 450, 451, 0, 452, 1296, 454, 455, 456, 457, + 458, 0, 459, 1092, 1093, 0, 0, 462, 463, 801, + 465, 802, 1094, 467, 468, 1297, 470, 471, 472, 473, + 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 487, 1095, 489, + 1298, 490, 1299, 492, 493, 494, 495, 496, 497, 498, + 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 520, 1096, 0, 0, 0, + 0, 0, 0, 1097, 1098, 1099, 0, 0, 0, 0, + 1100, 0, 1101, 1300, 0, 0, 0, 0, 1102, 1103, + 1104, 1105, 117, 1056, 821, 1057, 1058, 0, 1060, 1061, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, + 126, 127, 128, 0, 0, 0, 0, 0, 1062, 0, + 0, 129, 130, 131, 0, 132, 133, 134, 135, 136, + 137, 138, 139, 1063, 141, 1064, 1065, 0, 144, 145, + 146, 147, 148, 149, 1066, 790, 150, 151, 152, 153, + 1067, 1068, 156, 0, 157, 158, 159, 160, 791, 0, + 792, 0, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 1070, 191, 192, 1071, 194, 0, 195, 0, 196, + 197, 198, 199, 200, 201, 14, 15, 202, 203, 204, + 205, 0, 0, 206, 207, 1073, 209, 210, 0, 211, + 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, + 220, 1074, 222, 223, 224, 225, 226, 227, 793, 1075, + 229, 0, 230, 231, 1076, 233, 0, 234, 0, 235, + 236, 23, 237, 238, 239, 240, 241, 242, 0, 243, + 0, 1077, 1078, 246, 247, 0, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 0, 0, 289, 290, 291, 292, 0, 293, 294, + 295, 296, 297, 298, 299, 300, 1082, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 1083, 323, 1084, + 325, 326, 327, 328, 0, 329, 330, 331, 332, 1086, + 795, 334, 1087, 336, 337, 338, 0, 339, 340, 0, + 0, 341, 342, 343, 0, 0, 344, 345, 346, 347, + 348, 349, 797, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 26, 27, 28, 0, 362, 363, + 798, 365, 366, 367, 368, 369, 370, 371, 0, 372, + 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, + 382, 1089, 384, 385, 386, 387, 0, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 0, 401, 402, 403, 404, 405, 406, 1090, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 33, 0, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 35, 430, 431, 432, 1091, 434, 0, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, 447, 448, 800, 37, 0, 450, 451, 38, 452, + 453, 454, 455, 456, 457, 458, 0, 459, 1092, 1093, + 0, 0, 462, 463, 801, 465, 802, 1094, 467, 468, + 803, 470, 471, 472, 473, 474, 0, 0, 475, 476, + 477, 40, 478, 479, 480, 481, 0, 482, 483, 484, + 485, 486, 804, 1095, 489, 0, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 0, 0, 499, 0, 44, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, + 520, 0, 0, 45, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1100, 0, 1101, 0, 0, + 0, 0, 0, 1102, 1103, 1104, 1105, 117, 1056, 821, + 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, + 0, 0, 0, 1062, 0, 0, 129, 130, 131, 0, + 132, 133, 134, 135, 136, 137, 138, 139, 1063, 141, + 1064, 1065, 1448, 144, 145, 146, 147, 148, 149, 1066, + 790, 150, 151, 152, 153, 1067, 1068, 156, 0, 157, + 158, 159, 160, 791, 0, 792, 0, 1069, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 1070, 191, 192, 1071, + 194, 1072, 195, 0, 196, 197, 198, 199, 200, 201, + 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, + 1073, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 1074, 222, 223, 224, + 225, 226, 227, 793, 1075, 229, 0, 230, 231, 1076, + 233, 0, 234, 0, 235, 236, 1449, 237, 238, 239, + 240, 241, 242, 0, 243, 0, 1077, 1078, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, + 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 1079, 1080, 0, 1081, 0, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 0, 1450, 289, 290, + 291, 292, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 1082, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 1083, 323, 1084, 325, 326, 327, 328, 1085, + 329, 330, 331, 332, 1086, 795, 334, 1087, 336, 337, + 338, 0, 339, 340, 0, 0, 1088, 342, 343, 0, + 0, 344, 345, 346, 347, 348, 349, 797, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, + 0, 0, 0, 362, 363, 798, 365, 366, 367, 368, + 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, + 0, 378, 379, 380, 381, 382, 1089, 384, 385, 386, + 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 0, 401, 402, 403, 404, + 405, 406, 1090, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 0, 430, 431, + 432, 1091, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 447, 448, 800, 0, + 0, 450, 451, 0, 452, 453, 454, 455, 456, 457, + 458, 0, 459, 1092, 1093, 0, 1451, 462, 463, 801, + 465, 802, 1094, 467, 468, 803, 470, 471, 472, 473, + 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 487, 1095, 489, + 0, 490, 491, 492, 493, 494, 495, 496, 497, 498, + 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 520, 1096, 0, 0, 0, + 0, 0, 0, 1097, 1098, 1099, 0, 0, 0, 0, + 1100, 0, 1101, 0, 0, 0, 0, 0, 1102, 1103, + 1104, 1105, 1264, 1056, 821, 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, + 126, 127, 128, 0, 0, 0, 1266, 0, 1062, 0, + 0, 1267, 130, 131, 0, 132, 133, 134, 1268, 136, + 137, 138, 139, 1063, 1269, 1064, 1065, 0, 144, 145, + 146, 147, 148, 149, 1066, 790, 150, 151, 152, 153, + 1067, 1068, 156, 0, 157, 158, 159, 160, 791, 0, + 1270, 0, 1271, 164, 165, 166, 167, 168, 1272, 170, + 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, + 1273, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 1070, 191, 192, 1071, 194, 1072, 195, 0, 196, + 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, + 205, 0, 0, 206, 207, 1073, 209, 210, 0, 211, + 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, + 220, 1074, 222, 223, 224, 225, 226, 227, 793, 1075, + 229, 0, 230, 231, 1076, 233, 0, 234, 0, 235, + 1275, 0, 1276, 238, 239, 1277, 1278, 242, 0, 243, + 0, 1077, 1078, 246, 247, 0, 248, 249, 250, 251, + 252, 253, 254, 1279, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 1280, 269, + 270, 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, + 278, 1281, 1282, 281, 1283, 283, 284, 285, 286, 287, + 288, 0, 0, 289, 1284, 291, 1285, 0, 293, 294, + 295, 296, 297, 298, 299, 300, 1286, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 1083, 1287, 1084, + 325, 326, 327, 328, 1085, 329, 330, 1288, 332, 1086, + 795, 334, 1087, 336, 337, 338, 0, 339, 340, 0, + 0, 1088, 342, 343, 0, 0, 344, 345, 346, 1289, + 348, 1290, 797, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, + 798, 1291, 366, 367, 368, 369, 370, 371, 0, 372, + 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, + 382, 1089, 384, 385, 386, 387, 0, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 0, 401, 402, 1292, 404, 405, 406, 1090, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 0, 1293, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 0, 1294, 431, 432, 1091, 434, 0, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, 1295, 448, 800, 0, 0, 450, 451, 0, 452, + 1296, 454, 455, 456, 457, 458, 0, 459, 1092, 1093, + 0, 0, 462, 463, 801, 465, 802, 1094, 467, 468, + 1297, 470, 471, 472, 473, 474, 0, 0, 475, 476, + 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, + 485, 486, 487, 1095, 489, 2334, 490, 1299, 492, 493, + 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, + 520, 1096, 0, 0, 0, 0, 0, 0, 1097, 1098, + 1099, 0, 0, 0, 0, 1100, 0, 1101, 0, 0, + 0, 0, 0, 1102, 1103, 1104, 1105, 1264, 1056, 821, + 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, + 0, 1266, 0, 1062, 0, 0, 1267, 130, 131, 0, + 132, 133, 134, 1268, 136, 137, 138, 139, 1063, 1269, + 1064, 1065, 0, 144, 145, 146, 147, 148, 149, 1066, + 790, 150, 151, 152, 153, 1067, 1068, 156, 0, 157, + 158, 159, 160, 791, 0, 1270, 0, 1271, 164, 165, + 166, 167, 168, 1272, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 1273, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 1070, 191, 192, 1071, + 194, 1072, 195, 0, 196, 197, 198, 199, 200, 201, + 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, + 1073, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 1074, 222, 223, 224, + 225, 226, 227, 793, 1075, 229, 0, 230, 231, 1076, + 233, 0, 234, 0, 235, 1275, 0, 1276, 238, 239, + 1277, 1278, 242, 0, 243, 0, 1077, 1078, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 1279, 256, + 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, + 266, 0, 267, 1280, 269, 270, 271, 272, 273, 274, + 1079, 1080, 0, 1081, 0, 278, 1281, 1282, 281, 1283, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 1284, + 291, 1285, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 1286, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 1083, 1287, 1084, 325, 326, 327, 328, 1085, + 329, 330, 1288, 332, 1086, 795, 334, 1087, 336, 337, + 338, 0, 339, 340, 0, 0, 1088, 342, 343, 0, + 0, 344, 345, 346, 1289, 348, 1290, 797, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, + 0, 0, 0, 362, 363, 798, 1291, 366, 367, 368, + 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, + 0, 378, 379, 380, 381, 382, 1089, 384, 385, 386, + 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 0, 401, 402, 1292, 404, + 405, 406, 1090, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 0, 1293, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 0, 1294, 431, + 432, 1091, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 1295, 448, 800, 0, + 0, 450, 451, 0, 452, 1296, 454, 455, 456, 457, + 458, 0, 459, 1092, 1093, 0, 0, 462, 463, 801, + 465, 802, 1094, 467, 468, 1297, 470, 471, 472, 473, + 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 487, 1095, 489, + 0, 490, 1299, 492, 493, 494, 495, 496, 497, 498, + 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 520, 1096, 0, 0, 0, + 0, 0, 0, 1097, 1098, 1099, 0, 0, 0, 0, + 1100, 0, 1101, 2389, 0, 0, 0, 0, 1102, 1103, + 1104, 1105, 117, 1056, 821, 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 118, 119, 120, 121, 122, 123, 124, 125, -1139, + 126, 127, 128, 0, 0, 0, 0, -1139, 1062, 0, + 0, 129, 130, 131, 0, 132, 133, 134, 135, 136, + 137, 138, 139, 1063, 141, 1064, 1065, 0, 144, 145, + 146, 147, 148, 149, 1066, 790, 150, 151, 152, 153, + 1067, 1068, 156, 0, 157, 158, 159, 160, 791, 0, + 792, 0, 1069, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 1070, 191, 192, 1071, 194, 1072, 195, 0, 196, + 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, + 205, 0, 0, 206, 207, 1073, 209, 210, 0, 211, + 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, + 220, 1074, 222, 223, 224, 225, 226, 227, 793, 1075, + 229, 0, 230, 231, 1076, 233, 0, 234, 0, 235, + 236, 0, 237, 238, 239, 240, 241, 242, 0, 243, + 0, 1077, 1078, 246, 247, 0, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 0, 0, 289, 290, 291, 292, 0, 293, 294, + 295, 296, 297, 298, 299, 300, 1082, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 1083, 323, 1084, + 325, 326, 327, 328, 1085, 329, 330, 331, 332, 1086, + 795, 334, 1087, 336, 337, 338, 0, 339, 340, 0, + 0, 1088, 342, 343, 0, 0, 344, 345, 346, 347, + 348, 349, 797, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, + 798, 365, 366, 367, 368, 369, 370, 371, 0, 372, + 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, + 382, 1089, 384, 385, 386, 387, 0, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 0, 401, 402, 403, 404, 405, 406, 1090, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 0, 430, 431, 432, 1091, 434, -1139, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, 447, 448, 800, 0, 0, 450, 451, 0, 452, + 453, 454, 455, 456, 457, 458, 0, 459, 1092, 1093, + 0, 0, 462, 463, 801, 465, 802, 1094, 467, 468, + 803, 470, 471, 472, 473, 474, 0, 0, 475, 476, + 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, + 485, 486, 487, 1095, 489, 0, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, + 520, 1096, 0, 0, 0, 0, 0, 0, 1097, 1098, + 1099, 0, 0, 0, 0, 1100, 0, 1101, 0, 0, + 0, 0, 0, 1102, 1103, 1104, 1105, 1264, 1056, 821, + 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, + 0, 1266, 0, 1062, 0, 0, 1267, 130, 131, 0, + 132, 133, 134, 1268, 136, 137, 138, 139, 1063, 1269, + 1064, 1065, 0, 144, 145, 146, 147, 148, 149, 1066, + 790, 150, 151, 152, 153, 1067, 1068, 156, 0, 157, + 158, 159, 160, 791, 0, 1270, 0, 1271, 164, 165, + 166, 167, 168, 1272, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 1273, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 1070, 191, 192, 1071, + 194, 1072, 195, 0, 196, 197, 198, 199, 200, 201, + 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, + 1073, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 1074, 222, 223, 224, + 225, 226, 227, 793, 1075, 229, 0, 230, 231, 1076, + 233, 0, 234, 0, 235, 1275, 0, 1276, 238, 239, + 1277, 1278, 242, 0, 243, 0, 1077, 1078, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 1279, 256, + 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, + 266, 0, 267, 1280, 269, 270, 271, 272, 273, 274, + 1079, 1080, 0, 1081, 0, 278, 1281, 1282, 281, 1283, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 1284, + 291, 1285, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 1286, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 1083, 1287, 1084, 325, 326, 327, 328, 1085, + 329, 330, 1288, 332, 1086, 795, 334, 1087, 336, 337, + 338, 0, 339, 340, 0, 0, 1088, 342, 343, 0, + 0, 344, 345, 346, 1289, 348, 1290, 797, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, + 0, 0, 0, 362, 363, 798, 1291, 366, 367, 368, + 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, + 0, 378, 379, 380, 381, 382, 1089, 384, 385, 386, + 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 0, 401, 402, 1292, 404, + 405, 406, 1090, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 0, 1293, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 0, 1294, 431, + 432, 1091, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 1295, 448, 800, 0, + 0, 450, 451, 0, 452, 1296, 454, 455, 456, 457, + 458, 0, 459, 1092, 1093, 0, 0, 462, 463, 801, + 465, 802, 1094, 467, 468, 1297, 470, 471, 472, 473, + 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 487, 1095, 489, + 0, 490, 1299, 492, 493, 494, 495, 496, 497, 498, + 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 520, 1096, 0, 0, 0, + 0, 0, 0, 1097, 1098, 1099, 0, 0, 0, 0, + 1100, 0, 1101, 3159, 0, 0, 0, 0, 1102, 1103, + 1104, 1105, 1264, 1056, 821, 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, + 126, 127, 128, 0, 0, 0, 1266, 0, 1062, 0, + 0, 1267, 130, 131, 0, 132, 133, 134, 1268, 136, + 137, 138, 139, 1063, 1269, 1064, 1065, 0, 144, 145, + 146, 147, 148, 149, 1066, 790, 150, 151, 152, 153, + 1067, 1068, 156, 0, 157, 158, 159, 160, 791, 0, + 1270, 0, 1271, 164, 165, 166, 167, 168, 1272, 170, + 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, + 1273, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 1070, 191, 192, 1071, 194, 1072, 195, 0, 196, + 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, + 205, 0, 0, 206, 207, 1073, 209, 210, 0, 211, + 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, + 220, 1074, 222, 223, 224, 225, 226, 227, 793, 1075, + 229, 0, 230, 231, 1076, 233, 0, 234, 0, 235, + 1275, 0, 1276, 238, 239, 1277, 1278, 242, 0, 243, + 0, 1077, 1078, 246, 247, 0, 248, 249, 250, 251, + 252, 253, 254, 1279, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 1280, 269, + 270, 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, + 278, 1281, 1282, 281, 1283, 283, 284, 285, 286, 287, + 288, 0, 0, 289, 1284, 291, 1285, 0, 293, 294, + 295, 296, 297, 298, 299, 300, 1286, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 1083, 1287, 1084, + 325, 326, 327, 328, 1085, 329, 330, 1288, 332, 1086, + 795, 334, 1087, 336, 337, 338, 0, 339, 340, 0, + 0, 1088, 342, 343, 0, 0, 344, 345, 346, 1289, + 348, 1290, 797, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, + 798, 1291, 366, 367, 368, 369, 370, 371, 0, 372, + 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, + 382, 1089, 384, 385, 386, 387, 0, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 0, 401, 402, 1292, 404, 405, 406, 1090, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 0, 1293, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 0, 1294, 431, 432, 1091, 434, 0, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, 1295, 448, 800, 0, 0, 450, 451, 0, 452, + 1296, 454, 455, 456, 457, 458, 0, 459, 1092, 1093, + 0, 0, 462, 463, 801, 465, 802, 1094, 467, 468, + 1297, 470, 471, 472, 473, 474, 0, 0, 475, 476, + 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, + 485, 486, 487, 1095, 489, 0, 490, 1299, 492, 493, + 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, + 520, 1096, 0, 0, 0, 0, 0, 0, 1097, 1098, + 1099, 0, 0, 0, 0, 1100, 0, 1101, 0, 0, + 0, 0, 0, 1102, 1103, 1104, 1105, 117, 1056, 821, + 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 1717, 126, 127, 128, 0, 0, + 0, 0, 0, 1062, 0, 0, 129, 130, 131, 0, + 132, 133, 134, 135, 136, 137, 138, 139, 1063, 141, + 1064, 1065, 0, 144, 145, 146, 147, 148, 149, 1066, + 790, 150, 151, 152, 153, 1067, 1068, 156, 0, 157, + 158, 159, 160, 791, 0, 792, 0, 1069, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 1070, 191, 192, 1071, + 194, 1072, 195, 0, 196, 197, 198, 199, 200, 201, + 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, + 1073, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 1074, 222, 223, 224, + 225, 226, 227, 793, 1075, 229, 0, 230, 231, 1076, + 233, 0, 234, 0, 235, 236, 0, 237, 238, 239, + 240, 241, 242, 0, 243, 0, 1077, 1078, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, + 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 1079, 1080, 0, 1081, 0, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 290, + 291, 292, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 1082, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 1083, 323, 1084, 325, 326, 327, 328, 1085, + 329, 330, 331, 332, 1086, 795, 334, 1087, 336, 337, + 338, 0, 339, 340, 0, 0, 1088, 342, 343, 0, + 0, 344, 345, 346, 347, 348, 349, 797, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, + 0, 0, 0, 362, 363, 798, 365, 366, 367, 368, + 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, + 0, 378, 379, 380, 381, 382, 1089, 384, 385, 386, + 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 0, 401, 402, 403, 404, + 405, 406, 1090, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 0, 430, 431, + 432, 1091, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 447, 448, 800, 0, + 0, 450, 451, 0, 452, 453, 454, 455, 456, 457, + 458, 0, 459, 1092, 1093, 0, 0, 462, 463, 801, + 465, 802, 1094, 467, 468, 803, 470, 471, 472, 473, + 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 487, 1095, 489, + 0, 490, 491, 492, 493, 494, 495, 496, 497, 498, + 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 520, 1096, 0, 0, 0, + 0, 0, 0, 1097, 1098, 1099, 0, 0, 0, 0, + 1100, 0, 1101, 0, 0, 0, 0, 0, 1102, 1103, + 1104, 1105, 117, 1732, 821, 1057, 1058, 1059, 1733, 1061, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1676, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1676, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1676, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1676, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 117, 1056, 821, 1057, - 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1676, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 0, 0, 1062, 0, 0, 129, 130, 131, 0, 132, - 133, 134, 135, 136, 137, 138, 139, 1063, 141, 1064, - 1065, 0, 144, 145, 146, 147, 148, 149, 1066, 790, - 150, 151, 152, 153, 1067, 1068, 156, 1676, 157, 158, - 159, 160, 791, 0, 792, 0, 1069, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 1070, 191, 192, 1071, 194, - 1072, 195, 0, 196, 197, 198, 199, 200, 201, 14, - 15, 202, 203, 204, 205, 0, 0, 206, 207, 1073, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 1074, 222, 223, 224, 225, - 226, 227, 793, 1075, 229, 0, 230, 231, 1076, 233, - 0, 234, 0, 235, 236, 23, 237, 238, 239, 240, - 241, 242, 0, 243, 0, 1077, 1078, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 1079, - 1080, 0, 1081, 0, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 290, 291, - 292, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 1082, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 1083, 323, 1084, 325, 326, 327, 328, 1085, 329, - 330, 331, 332, 1086, 795, 334, 1087, 336, 337, 338, - 0, 339, 340, 0, 0, 1088, 342, 343, 0, 0, - 344, 345, 346, 347, 348, 349, 797, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 26, 27, - 28, 0, 362, 363, 798, 365, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 1089, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 403, 404, 405, - 406, 1090, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 33, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 35, 430, 431, 432, - 1091, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 447, 448, 800, 37, 0, - 450, 451, 38, 452, 453, 454, 455, 456, 457, 458, - 0, 459, 1092, 1093, 0, 0, 462, 463, 801, 465, - 802, 1094, 467, 468, 803, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 40, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 804, 1095, 489, 0, - 490, 491, 492, 493, 494, 495, 496, 497, 498, 0, - 0, 499, 0, 44, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 520, 1096, 0, 45, 0, 0, - 0, 0, 1097, 1098, 1099, 0, 0, 0, 0, 1100, - 0, 1101, 3292, 0, 0, 0, 0, 1102, 1103, 1104, - 1105, 117, 1056, 821, 1057, 1058, 1059, 1060, 1061, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, - 127, 128, 0, 0, 0, 0, 0, 1062, 0, 0, - 129, 130, 131, 0, 132, 133, 134, 135, 136, 137, - 138, 139, 1063, 141, 1064, 1065, 0, 144, 145, 146, - 147, 148, 149, 1066, 790, 150, 151, 152, 153, 1067, - 1068, 156, 0, 157, 158, 159, 160, 791, 0, 792, - 0, 1069, 164, 165, 166, 167, 168, 169, 170, 171, - 172, 0, 173, 174, 175, 176, 177, 178, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 1070, 191, 192, 1071, 194, 1072, 195, 0, 196, 197, - 198, 199, 200, 201, 14, 15, 202, 203, 204, 205, - 0, 0, 206, 207, 1073, 209, 210, 0, 211, 212, - 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, - 1074, 222, 223, 224, 225, 226, 227, 793, 1075, 229, - 0, 230, 231, 1076, 233, 0, 234, 0, 235, 236, - 23, 237, 238, 239, 240, 241, 242, 0, 243, 0, - 1077, 1078, 246, 247, 0, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, - 262, 263, 264, 265, 266, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, - 0, 0, 289, 290, 291, 292, 0, 293, 294, 295, - 296, 297, 298, 299, 300, 1082, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 1083, 323, 1084, 325, - 326, 327, 328, 1085, 329, 330, 331, 332, 1086, 795, - 334, 1087, 336, 337, 338, 0, 339, 340, 0, 0, - 1088, 342, 343, 0, 0, 344, 345, 346, 347, 348, - 349, 797, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, 361, 26, 27, 28, 0, 362, 363, 798, - 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, - 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, - 1089, 384, 385, 386, 387, 0, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, - 401, 402, 403, 404, 405, 406, 1090, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 33, 0, 421, 422, 423, 424, 425, 426, 427, 428, - 429, 35, 430, 431, 432, 1091, 434, 0, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - 447, 448, 800, 37, 0, 450, 451, 38, 452, 453, - 454, 455, 456, 457, 458, 0, 459, 1092, 1093, 0, - 0, 462, 463, 801, 465, 802, 1094, 467, 468, 803, - 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, - 40, 478, 479, 480, 481, 0, 482, 483, 484, 485, - 486, 804, 1095, 489, 0, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 0, 0, 499, 0, 44, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, - 1096, 0, 45, 0, 0, 0, 0, 1097, 1098, 1099, - 0, 0, 0, 0, 1100, 0, 1101, 0, 0, 0, - 0, 0, 1102, 1103, 1104, 1105, 117, 1056, 821, 1057, - 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 0, 0, 1062, 0, 0, 129, 130, 131, 0, 132, - 133, 134, 135, 136, 137, 138, 139, 1063, 141, 1064, - 1065, 0, 144, 145, 146, 147, 148, 149, 1066, 790, - 150, 151, 152, 153, 1067, 1068, 156, 0, 157, 158, - 159, 160, 791, 0, 792, 0, 1069, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 1070, 191, 192, 1071, 194, - 1072, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 1073, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 1074, 222, 223, 224, 225, - 226, 227, 793, 1075, 229, 0, 230, 231, 1076, 233, - 0, 234, 0, 235, 236, 23, 237, 238, 239, 240, - 241, 242, 0, 243, 0, 1077, 1078, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 1079, - 1080, 0, 1081, 0, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 290, 291, - 292, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 1082, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 1083, 323, 1084, 325, 326, 327, 328, 1085, 329, - 330, 331, 332, 1086, 795, 334, 1087, 336, 337, 338, - 0, 339, 340, 0, 0, 1088, 342, 343, 0, 0, - 344, 345, 346, 347, 348, 349, 797, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 26, 27, - 28, 0, 362, 363, 798, 365, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 1089, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 403, 404, 405, - 406, 1090, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 33, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 430, 431, 432, - 1091, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 447, 448, 800, 0, 0, - 450, 451, 38, 452, 453, 454, 455, 456, 457, 458, - 0, 459, 1092, 1093, 0, 0, 462, 463, 801, 465, - 802, 1094, 467, 468, 803, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 40, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 804, 1095, 489, 0, - 490, 491, 492, 493, 494, 495, 496, 497, 498, 0, - 0, 499, 0, 44, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 520, 1096, 0, 45, 0, 0, - 0, 0, 1097, 1098, 1099, 0, 0, 0, 0, 1100, - 0, 1101, 0, 0, 0, 0, 0, 1102, 1103, 1104, - 1105, 1264, 1056, 821, 1057, 1058, 1059, 1060, 1061, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 118, 119, 120, 121, 122, 123, 124, 125, 1265, 126, - 127, 128, 0, 0, 0, 1266, 0, 1062, 0, 0, - 1267, 130, 131, 0, 132, 133, 134, 1268, 136, 137, - 138, 139, 1063, 1269, 1064, 1065, 0, 144, 145, 146, - 147, 148, 149, 1066, 790, 150, 151, 152, 153, 1067, - 1068, 156, 0, 157, 158, 159, 160, 791, 0, 1270, - 0, 1271, 164, 165, 166, 167, 168, 1272, 170, 171, - 172, 0, 173, 174, 175, 176, 177, 178, 0, 1273, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 1070, 191, 192, 1071, 194, 1072, 195, 0, 196, 197, - 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, - 1274, 0, 206, 207, 1073, 209, 210, 0, 211, 212, - 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, - 1074, 222, 223, 224, 225, 226, 227, 793, 1075, 229, - 0, 230, 231, 1076, 233, 0, 234, 0, 235, 1275, - 0, 1276, 238, 239, 1277, 1278, 242, 0, 243, 0, - 1077, 1078, 246, 247, 0, 248, 249, 250, 251, 252, - 253, 254, 1279, 256, 257, 258, 259, 0, 260, 261, - 262, 263, 264, 265, 266, 0, 267, 1280, 269, 270, - 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, 278, - 1281, 1282, 281, 1283, 283, 284, 285, 286, 287, 288, - 0, 0, 289, 1284, 291, 1285, 0, 293, 294, 295, - 296, 297, 298, 299, 300, 1286, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 1083, 1287, 1084, 325, - 326, 327, 328, 1085, 329, 330, 1288, 332, 1086, 795, - 334, 1087, 336, 337, 338, 0, 339, 340, 0, 0, - 1088, 342, 343, 0, 881, 344, 345, 346, 1289, 348, - 1290, 797, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, 361, 0, 0, 0, 0, 362, 363, 798, - 1291, 366, 367, 368, 369, 370, 371, 0, 372, 373, - 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, - 1089, 384, 385, 386, 387, 0, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, - 401, 402, 1292, 404, 405, 406, 1090, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 0, 1293, 421, 422, 423, 424, 425, 426, 427, 428, - 429, 0, 1294, 431, 432, 1091, 434, 0, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - 1295, 448, 800, 0, 0, 450, 451, 0, 452, 1296, - 454, 455, 456, 457, 458, 0, 459, 1092, 1093, 0, - 0, 462, 463, 801, 465, 802, 1094, 467, 468, 1297, - 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, - 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, - 486, 487, 1095, 489, 1298, 490, 1299, 492, 493, 494, - 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, - 1096, 0, 0, 0, 0, 0, 0, 1097, 1098, 1099, - 0, 0, 0, 0, 1100, 0, 1101, 1300, 0, 0, - 0, 0, 1102, 1103, 1104, 1105, 117, 1056, 821, 1057, - 1058, 0, 1060, 1061, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 0, 0, 1062, 0, 0, 129, 130, 131, 0, 132, - 133, 134, 135, 136, 137, 138, 139, 1063, 141, 1064, - 1065, 0, 144, 145, 146, 147, 148, 149, 1066, 790, - 150, 151, 152, 153, 1067, 1068, 156, 0, 157, 158, - 159, 160, 791, 0, 792, 0, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 1070, 191, 192, 1071, 194, - 0, 195, 0, 196, 197, 198, 199, 200, 201, 14, - 15, 202, 203, 204, 205, 0, 0, 206, 207, 1073, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 1074, 222, 223, 224, 225, - 226, 227, 793, 1075, 229, 0, 230, 231, 1076, 233, - 0, 234, 0, 235, 236, 23, 237, 238, 239, 240, - 241, 242, 0, 243, 0, 1077, 1078, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 1079, - 1080, 0, 1081, 0, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 290, 291, - 292, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 1082, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 1083, 323, 1084, 325, 326, 327, 328, 0, 329, - 330, 331, 332, 1086, 795, 334, 1087, 336, 337, 338, - 0, 339, 340, 0, 0, 341, 342, 343, 0, 0, - 344, 345, 346, 347, 348, 349, 797, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 26, 27, - 28, 0, 362, 363, 798, 365, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 1089, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 403, 404, 405, - 406, 1090, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 33, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 35, 430, 431, 432, - 1091, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 447, 448, 800, 37, 0, - 450, 451, 38, 452, 453, 454, 455, 456, 457, 458, - 0, 459, 1092, 1093, 0, 0, 462, 463, 801, 465, - 802, 1094, 467, 468, 803, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 40, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 804, 1095, 489, 0, - 490, 491, 492, 493, 494, 495, 496, 497, 498, 0, - 0, 499, 0, 44, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 520, 0, 0, 45, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1100, - 0, 1101, 0, 0, 0, 0, 0, 1102, 1103, 1104, - 1105, 117, 1056, 821, 1057, 1058, 1059, 1060, 1061, 0, + 0, 118, 119, 120, 121, 122, 123, 124, 125, 1734, + 126, 127, 128, 0, 0, 0, 0, 0, 1062, 0, + 0, 129, 130, 131, 0, 132, 133, 134, 135, 136, + 137, 138, 139, 1063, 141, 1064, 1065, 0, 144, 145, + 146, 147, 148, 149, 1066, 790, 150, 151, 152, 153, + 1067, 1068, 156, 0, 157, 158, 159, 160, 791, 0, + 792, 0, 1069, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 1070, 191, 192, 1071, 194, 1072, 195, 0, 196, + 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, + 205, 0, 0, 206, 207, 1073, 209, 210, 0, 211, + 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, + 220, 1074, 222, 223, 224, 225, 226, 227, 793, 1075, + 229, 0, 230, 231, 1076, 233, 0, 234, 0, 235, + 236, 0, 237, 238, 239, 240, 241, 242, 0, 243, + 0, 1077, 1078, 246, 247, 0, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 0, 0, 289, 290, 291, 292, 0, 293, 294, + 295, 296, 297, 298, 299, 300, 1082, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 1083, 323, 1084, + 325, 326, 327, 328, 1085, 329, 330, 331, 332, 1086, + 795, 334, 1087, 336, 337, 338, 0, 339, 340, 0, + 0, 1088, 342, 343, 0, 0, 344, 345, 346, 347, + 348, 349, 797, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, + 798, 365, 366, 367, 368, 369, 370, 371, 0, 372, + 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, + 382, 1089, 384, 385, 386, 387, 0, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 0, 401, 402, 403, 404, 405, 406, 1090, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 0, 430, 431, 432, 1091, 434, 0, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, 447, 448, 800, 0, 0, 450, 451, 0, 452, + 453, 454, 455, 456, 457, 458, 0, 459, 1092, 1093, + 0, 0, 462, 463, 801, 465, 802, 1094, 467, 468, + 803, 470, 471, 472, 473, 474, 0, 0, 475, 476, + 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, + 485, 486, 487, 1095, 489, 0, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, + 520, 1096, 0, 0, 0, 0, 0, 0, 1097, 1098, + 1099, 0, 0, 0, 0, 1100, 0, 1101, 0, 0, + 0, 0, 0, 1102, 1103, 1104, 1105, 117, 1056, 821, + 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, + 0, 0, 0, 1062, 0, 0, 129, 130, 131, 0, + 132, 133, 134, 135, 136, 137, 138, 139, 1063, 141, + 1064, 1065, 0, 144, 145, 146, 147, 148, 149, 1066, + 790, 150, 151, 152, 153, 1067, 1068, 156, 0, 157, + 158, 159, 160, 791, 0, 792, 0, 1069, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 1070, 191, 192, 1071, + 194, 1072, 195, 0, 196, 197, 198, 199, 200, 201, + 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, + 1073, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 1074, 222, 223, 224, + 225, 226, 227, 793, 1075, 229, 0, 230, 231, 1076, + 233, 0, 234, 0, 235, 236, 1449, 237, 238, 239, + 240, 241, 242, 0, 243, 0, 1077, 1078, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, + 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 1079, 1080, 0, 1081, 0, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 290, + 291, 292, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 1082, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 1083, 323, 1084, 325, 326, 327, 328, 1085, + 329, 330, 331, 332, 1086, 795, 334, 1087, 336, 337, + 338, 0, 339, 340, 0, 0, 1088, 342, 343, 0, + 0, 344, 345, 346, 347, 348, 349, 797, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, + 0, 0, 0, 362, 363, 798, 365, 366, 367, 368, + 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, + 0, 378, 379, 380, 381, 382, 1089, 384, 385, 386, + 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 0, 401, 402, 403, 404, + 405, 406, 1090, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 0, 430, 431, + 432, 1091, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 447, 448, 800, 0, + 0, 450, 451, 0, 452, 453, 454, 455, 456, 457, + 458, 0, 459, 1092, 1093, 0, 0, 462, 463, 801, + 465, 802, 1094, 467, 468, 803, 470, 471, 472, 473, + 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 487, 1095, 489, + 0, 490, 491, 492, 493, 494, 495, 496, 497, 498, + 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 520, 1096, 0, 0, 0, + 0, 0, 0, 1097, 1098, 1099, 0, 0, 0, 0, + 1100, 0, 1101, 0, 0, 0, 0, 0, 1102, 1103, + 1104, 1105, 117, 1056, 821, 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, - 127, 128, 0, 0, 0, 0, 0, 1062, 0, 0, - 129, 130, 131, 0, 132, 133, 134, 135, 136, 137, - 138, 139, 1063, 141, 1064, 1065, 1448, 144, 145, 146, - 147, 148, 149, 1066, 790, 150, 151, 152, 153, 1067, - 1068, 156, 0, 157, 158, 159, 160, 791, 0, 792, - 0, 1069, 164, 165, 166, 167, 168, 169, 170, 171, - 172, 0, 173, 174, 175, 176, 177, 178, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 1070, 191, 192, 1071, 194, 1072, 195, 0, 196, 197, - 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, - 0, 0, 206, 207, 1073, 209, 210, 0, 211, 212, - 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, - 1074, 222, 223, 224, 225, 226, 227, 793, 1075, 229, - 0, 230, 231, 1076, 233, 0, 234, 0, 235, 236, - 1449, 237, 238, 239, 240, 241, 242, 0, 243, 0, - 1077, 1078, 246, 247, 0, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, - 262, 263, 264, 265, 266, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, - 0, 1450, 289, 290, 291, 292, 0, 293, 294, 295, - 296, 297, 298, 299, 300, 1082, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 1083, 323, 1084, 325, - 326, 327, 328, 1085, 329, 330, 331, 332, 1086, 795, - 334, 1087, 336, 337, 338, 0, 339, 340, 0, 0, - 1088, 342, 343, 0, 0, 344, 345, 346, 347, 348, - 349, 797, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, 361, 0, 0, 0, 0, 362, 363, 798, - 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, - 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, - 1089, 384, 385, 386, 387, 0, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, - 401, 402, 403, 404, 405, 406, 1090, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, - 429, 0, 430, 431, 432, 1091, 434, 0, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - 447, 448, 800, 0, 0, 450, 451, 0, 452, 453, - 454, 455, 456, 457, 458, 0, 459, 1092, 1093, 0, - 1451, 462, 463, 801, 465, 802, 1094, 467, 468, 803, - 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, - 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, - 486, 487, 1095, 489, 0, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, - 1096, 0, 0, 0, 0, 0, 0, 1097, 1098, 1099, - 0, 0, 0, 0, 1100, 0, 1101, 0, 0, 0, - 0, 0, 1102, 1103, 1104, 1105, 1264, 1056, 821, 1057, - 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 1266, 0, 1062, 0, 0, 1267, 130, 131, 0, 132, - 133, 134, 1268, 136, 137, 138, 139, 1063, 1269, 1064, - 1065, 0, 144, 145, 146, 147, 148, 149, 1066, 790, - 150, 151, 152, 153, 1067, 1068, 156, 0, 157, 158, - 159, 160, 791, 0, 1270, 0, 1271, 164, 165, 166, - 167, 168, 1272, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 1273, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 1070, 191, 192, 1071, 194, - 1072, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 1073, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 1074, 222, 223, 224, 225, - 226, 227, 793, 1075, 229, 0, 230, 231, 1076, 233, - 0, 234, 0, 235, 1275, 0, 1276, 238, 239, 1277, - 1278, 242, 0, 243, 0, 1077, 1078, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 1279, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 1280, 269, 270, 271, 272, 273, 274, 1079, - 1080, 0, 1081, 0, 278, 1281, 1282, 281, 1283, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 1284, 291, - 1285, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 1286, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 1083, 1287, 1084, 325, 326, 327, 328, 1085, 329, - 330, 1288, 332, 1086, 795, 334, 1087, 336, 337, 338, - 0, 339, 340, 0, 0, 1088, 342, 343, 0, 0, - 344, 345, 346, 1289, 348, 1290, 797, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 798, 1291, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 1089, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 1292, 404, 405, - 406, 1090, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 1293, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 1294, 431, 432, - 1091, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 1295, 448, 800, 0, 0, - 450, 451, 0, 452, 1296, 454, 455, 456, 457, 458, - 0, 459, 1092, 1093, 0, 0, 462, 463, 801, 465, - 802, 1094, 467, 468, 1297, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 1095, 489, 2329, - 490, 1299, 492, 493, 494, 495, 496, 497, 498, 0, - 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 520, 1096, 0, 0, 0, 0, - 0, 0, 1097, 1098, 1099, 0, 0, 0, 0, 1100, - 0, 1101, 0, 0, 0, 0, 0, 1102, 1103, 1104, - 1105, 1264, 1056, 821, 1057, 1058, 1059, 1060, 1061, 0, + 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, + 126, 127, 128, 0, 0, 0, 0, 0, 1062, 0, + 0, 129, 130, 131, 0, 132, 133, 134, 135, 136, + 137, 138, 139, 1063, 141, 1064, 1065, 0, 144, 145, + 146, 147, 148, 149, 1066, 790, 150, 151, 152, 153, + 1067, 1068, 156, 0, 157, 158, 159, 160, 791, 0, + 792, 0, 1069, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 1070, 191, 192, 1071, 194, 1072, 195, 0, 196, + 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, + 205, 0, 0, 206, 207, 1073, 209, 210, 0, 211, + 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, + 220, 1074, 222, 223, 224, 225, 226, 227, 793, 1075, + 229, 0, 230, 231, 1076, 233, 0, 234, 0, 235, + 236, 0, 237, 238, 239, 240, 241, 242, 0, 243, + 0, 1077, 1078, 246, 247, 0, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 0, 0, 289, 290, 291, 292, 0, 293, 294, + 295, 296, 297, 298, 299, 300, 1082, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 1083, 323, 1084, + 325, 326, 327, 328, 1085, 329, 330, 331, 332, 1086, + 795, 334, 1087, 336, 337, 338, 0, 339, 340, 0, + 0, 1088, 342, 343, 0, 0, 344, 345, 346, 347, + 348, 349, 797, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, + 798, 365, 366, 367, 368, 369, 370, 371, 0, 372, + 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, + 382, 1089, 384, 385, 386, 387, 0, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 0, 401, 402, 403, 404, 405, 406, 1090, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 0, 430, 431, 432, 1091, 434, 0, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, 447, 448, 800, 0, 0, 450, 451, 0, 452, + 453, 454, 455, 456, 457, 458, 0, 459, 1092, 1093, + 0, 0, 462, 463, 801, 465, 802, 1094, 467, 468, + 803, 470, 471, 472, 473, 474, 0, 0, 475, 476, + 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, + 485, 486, 487, 1095, 489, 0, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, + 520, 1096, 0, 0, 0, 0, 0, 0, 1097, 1098, + 1099, 0, 0, 0, 0, 1100, 0, 1101, 2096, 0, + 0, 0, 0, 1102, 1103, 1104, 1105, 117, 1056, 821, + 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, + 0, 0, 0, 1062, 0, 0, 129, 130, 131, 0, + 132, 133, 134, 135, 136, 137, 138, 139, 1063, 141, + 1064, 1065, 0, 144, 145, 146, 147, 148, 149, 1066, + 790, 150, 151, 152, 153, 1067, 1068, 156, 0, 157, + 158, 159, 160, 791, 0, 792, 0, 1069, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 1070, 191, 192, 1071, + 194, 1072, 195, 0, 196, 197, 198, 199, 200, 201, + 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, + 1073, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 1074, 222, 223, 224, + 225, 226, 227, 793, 1075, 229, 0, 230, 231, 1076, + 233, 0, 234, 0, 235, 236, 0, 237, 238, 239, + 240, 241, 242, 0, 243, 0, 1077, 1078, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, + 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 1079, 1080, 0, 1081, 0, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 290, + 291, 292, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 1082, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 1083, 323, 1084, 325, 326, 327, 328, 1085, + 329, 330, 331, 332, 1086, 795, 334, 1087, 336, 337, + 338, 0, 339, 340, 0, 0, 1088, 342, 343, 0, + 0, 344, 345, 346, 347, 348, 349, 797, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, + 0, 0, 0, 362, 363, 798, 365, 366, 367, 368, + 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, + 0, 378, 379, 380, 381, 382, 1089, 384, 385, 386, + 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 0, 401, 402, 403, 404, + 405, 406, 1090, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 0, 430, 431, + 432, 1091, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 447, 448, 800, 0, + 0, 450, 451, 0, 452, 453, 454, 455, 456, 457, + 458, 0, 459, 1092, 1093, 0, 0, 462, 463, 801, + 465, 802, 1094, 467, 468, 803, 470, 471, 472, 473, + 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 487, 1095, 489, + 0, 490, 491, 492, 493, 494, 495, 496, 497, 498, + 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 520, 1096, 0, 0, 0, + 0, 0, 0, 1097, 1098, 1099, 0, 0, 0, 0, + 1100, 0, 1101, 0, 0, 0, 0, 2695, 1102, 1103, + 1104, 1105, 117, 1056, 821, 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, - 127, 128, 0, 0, 0, 1266, 0, 1062, 0, 0, - 1267, 130, 131, 0, 132, 133, 134, 1268, 136, 137, - 138, 139, 1063, 1269, 1064, 1065, 0, 144, 145, 146, - 147, 148, 149, 1066, 790, 150, 151, 152, 153, 1067, - 1068, 156, 0, 157, 158, 159, 160, 791, 0, 1270, - 0, 1271, 164, 165, 166, 167, 168, 1272, 170, 171, - 172, 0, 173, 174, 175, 176, 177, 178, 0, 1273, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 1070, 191, 192, 1071, 194, 1072, 195, 0, 196, 197, - 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, - 0, 0, 206, 207, 1073, 209, 210, 0, 211, 212, - 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, - 1074, 222, 223, 224, 225, 226, 227, 793, 1075, 229, - 0, 230, 231, 1076, 233, 0, 234, 0, 235, 1275, - 0, 1276, 238, 239, 1277, 1278, 242, 0, 243, 0, - 1077, 1078, 246, 247, 0, 248, 249, 250, 251, 252, - 253, 254, 1279, 256, 257, 258, 259, 0, 260, 261, - 262, 263, 264, 265, 266, 0, 267, 1280, 269, 270, - 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, 278, - 1281, 1282, 281, 1283, 283, 284, 285, 286, 287, 288, - 0, 0, 289, 1284, 291, 1285, 0, 293, 294, 295, - 296, 297, 298, 299, 300, 1286, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 1083, 1287, 1084, 325, - 326, 327, 328, 1085, 329, 330, 1288, 332, 1086, 795, - 334, 1087, 336, 337, 338, 0, 339, 340, 0, 0, - 1088, 342, 343, 0, 0, 344, 345, 346, 1289, 348, - 1290, 797, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, 361, 0, 0, 0, 0, 362, 363, 798, - 1291, 366, 367, 368, 369, 370, 371, 0, 372, 373, - 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, - 1089, 384, 385, 386, 387, 0, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, - 401, 402, 1292, 404, 405, 406, 1090, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 0, 1293, 421, 422, 423, 424, 425, 426, 427, 428, - 429, 0, 1294, 431, 432, 1091, 434, 0, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - 1295, 448, 800, 0, 0, 450, 451, 0, 452, 1296, - 454, 455, 456, 457, 458, 0, 459, 1092, 1093, 0, - 0, 462, 463, 801, 465, 802, 1094, 467, 468, 1297, - 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, - 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, - 486, 487, 1095, 489, 0, 490, 1299, 492, 493, 494, - 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, - 1096, 0, 0, 0, 0, 0, 0, 1097, 1098, 1099, - 0, 0, 0, 0, 1100, 0, 1101, 2386, 0, 0, - 0, 0, 1102, 1103, 1104, 1105, 117, 1056, 821, 1057, - 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, -1139, 126, 127, 128, 0, 0, 0, - 0, -1139, 1062, 0, 0, 129, 130, 131, 0, 132, - 133, 134, 135, 136, 137, 138, 139, 1063, 141, 1064, - 1065, 0, 144, 145, 146, 147, 148, 149, 1066, 790, - 150, 151, 152, 153, 1067, 1068, 156, 0, 157, 158, - 159, 160, 791, 0, 792, 0, 1069, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 1070, 191, 192, 1071, 194, - 1072, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 1073, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 1074, 222, 223, 224, 225, - 226, 227, 793, 1075, 229, 0, 230, 231, 1076, 233, - 0, 234, 0, 235, 236, 0, 237, 238, 239, 240, - 241, 242, 0, 243, 0, 1077, 1078, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 1079, - 1080, 0, 1081, 0, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 290, 291, - 292, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 1082, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 1083, 323, 1084, 325, 326, 327, 328, 1085, 329, - 330, 331, 332, 1086, 795, 334, 1087, 336, 337, 338, - 0, 339, 340, 0, 0, 1088, 342, 343, 0, 0, - 344, 345, 346, 347, 348, 349, 797, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 798, 365, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 1089, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 403, 404, 405, - 406, 1090, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 430, 431, 432, - 1091, 434, -1139, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 447, 448, 800, 0, 0, - 450, 451, 0, 452, 453, 454, 455, 456, 457, 458, - 0, 459, 1092, 1093, 0, 0, 462, 463, 801, 465, - 802, 1094, 467, 468, 803, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 1095, 489, 0, - 490, 491, 492, 493, 494, 495, 496, 497, 498, 0, - 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 520, 1096, 0, 0, 0, 0, - 0, 0, 1097, 1098, 1099, 0, 0, 0, 0, 1100, - 0, 1101, 0, 0, 0, 0, 0, 1102, 1103, 1104, - 1105, 1264, 1056, 821, 1057, 1058, 1059, 1060, 1061, 0, + 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, + 126, 127, 128, 0, 0, 0, 0, 0, 1062, 0, + 0, 129, 130, 131, 0, 132, 133, 134, 135, 136, + 137, 138, 139, 1063, 141, 1064, 1065, 0, 144, 145, + 146, 147, 148, 149, 1066, 790, 150, 151, 152, 153, + 1067, 1068, 156, 0, 157, 158, 159, 160, 791, 0, + 792, 0, 1069, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 1070, 191, 192, 1071, 194, 1072, 195, 0, 196, + 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, + 205, 0, 0, 206, 207, 1073, 209, 210, 0, 211, + 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, + 220, 1074, 222, 223, 224, 225, 226, 227, 793, 1075, + 229, 0, 230, 231, 1076, 233, 0, 234, 0, 235, + 236, 0, 237, 238, 239, 240, 241, 242, 0, 243, + 0, 1077, 1078, 246, 247, 0, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 0, 0, 289, 290, 291, 292, 0, 293, 294, + 295, 296, 297, 298, 299, 300, 1082, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 1083, 323, 1084, + 325, 326, 327, 328, 1085, 329, 330, 331, 332, 1086, + 795, 334, 1087, 336, 337, 338, 0, 339, 340, 0, + 0, 1088, 342, 343, 0, 0, 344, 345, 346, 347, + 348, 349, 797, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, + 798, 365, 366, 367, 368, 369, 370, 371, 0, 372, + 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, + 382, 1089, 384, 385, 386, 387, 0, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 0, 401, 402, 403, 404, 405, 406, 1090, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 0, 430, 431, 432, 1091, 434, 0, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, 447, 448, 800, 0, 0, 450, 451, 2752, 452, + 453, 454, 455, 456, 457, 458, 0, 459, 1092, 1093, + 0, 0, 462, 463, 801, 465, 802, 1094, 467, 468, + 803, 470, 471, 472, 473, 474, 0, 0, 475, 476, + 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, + 485, 486, 487, 1095, 489, 0, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, + 520, 1096, 0, 0, 0, 0, 0, 0, 1097, 1098, + 1099, 0, 0, 0, 0, 1100, 0, 1101, 0, 0, + 0, 0, 0, 1102, 1103, 1104, 1105, 117, 1056, 821, + 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, + 0, 0, 0, 1062, 0, 0, 129, 130, 131, 0, + 132, 133, 134, 135, 136, 137, 138, 139, 1063, 141, + 1064, 1065, 0, 144, 145, 146, 147, 148, 149, 1066, + 790, 150, 151, 152, 153, 1067, 1068, 156, 0, 157, + 158, 159, 160, 791, 0, 792, 0, 1069, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 1070, 191, 192, 1071, + 194, 1072, 195, 0, 196, 197, 198, 199, 200, 201, + 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, + 1073, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 1074, 222, 223, 224, + 225, 226, 227, 793, 1075, 229, 0, 230, 231, 1076, + 233, 0, 234, 0, 235, 236, 0, 237, 238, 239, + 240, 241, 242, 0, 243, 0, 1077, 1078, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, + 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 1079, 1080, 0, 1081, 0, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 290, + 291, 292, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 1082, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 1083, 323, 1084, 325, 326, 327, 328, 1085, + 329, 330, 331, 332, 1086, 795, 334, 1087, 336, 337, + 338, 0, 339, 340, 0, 0, 1088, 342, 343, 0, + 0, 344, 345, 346, 347, 348, 349, 797, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, + 0, 0, 0, 362, 363, 798, 365, 366, 367, 368, + 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, + 0, 378, 379, 380, 381, 382, 1089, 384, 385, 386, + 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 0, 401, 402, 403, 404, + 405, 406, 1090, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 0, 430, 431, + 432, 1091, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 447, 448, 800, 0, + 0, 450, 451, 0, 452, 453, 454, 455, 456, 457, + 458, 0, 459, 1092, 1093, 0, 0, 462, 463, 801, + 465, 802, 1094, 467, 468, 803, 470, 471, 472, 473, + 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 487, 1095, 489, + 0, 490, 491, 492, 493, 494, 495, 496, 497, 498, + 0, 2878, 499, 0, 0, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 520, 1096, 0, 0, 0, + 0, 0, 0, 1097, 1098, 1099, 0, 0, 0, 0, + 1100, 0, 1101, 0, 0, 0, 0, 0, 1102, 1103, + 1104, 1105, 117, 1056, 821, 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, - 127, 128, 0, 0, 0, 1266, 0, 1062, 0, 0, - 1267, 130, 131, 0, 132, 133, 134, 1268, 136, 137, - 138, 139, 1063, 1269, 1064, 1065, 0, 144, 145, 146, - 147, 148, 149, 1066, 790, 150, 151, 152, 153, 1067, - 1068, 156, 0, 157, 158, 159, 160, 791, 0, 1270, - 0, 1271, 164, 165, 166, 167, 168, 1272, 170, 171, - 172, 0, 173, 174, 175, 176, 177, 178, 0, 1273, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 1070, 191, 192, 1071, 194, 1072, 195, 0, 196, 197, - 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, - 0, 0, 206, 207, 1073, 209, 210, 0, 211, 212, - 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, - 1074, 222, 223, 224, 225, 226, 227, 793, 1075, 229, - 0, 230, 231, 1076, 233, 0, 234, 0, 235, 1275, - 0, 1276, 238, 239, 1277, 1278, 242, 0, 243, 0, - 1077, 1078, 246, 247, 0, 248, 249, 250, 251, 252, - 253, 254, 1279, 256, 257, 258, 259, 0, 260, 261, - 262, 263, 264, 265, 266, 0, 267, 1280, 269, 270, - 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, 278, - 1281, 1282, 281, 1283, 283, 284, 285, 286, 287, 288, - 0, 0, 289, 1284, 291, 1285, 0, 293, 294, 295, - 296, 297, 298, 299, 300, 1286, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 1083, 1287, 1084, 325, - 326, 327, 328, 1085, 329, 330, 1288, 332, 1086, 795, - 334, 1087, 336, 337, 338, 0, 339, 340, 0, 0, - 1088, 342, 343, 0, 0, 344, 345, 346, 1289, 348, - 1290, 797, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, 361, 0, 0, 0, 0, 362, 363, 798, - 1291, 366, 367, 368, 369, 370, 371, 0, 372, 373, - 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, - 1089, 384, 385, 386, 387, 0, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, - 401, 402, 1292, 404, 405, 406, 1090, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 0, 1293, 421, 422, 423, 424, 425, 426, 427, 428, - 429, 0, 1294, 431, 432, 1091, 434, 0, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - 1295, 448, 800, 0, 0, 450, 451, 0, 452, 1296, - 454, 455, 456, 457, 458, 0, 459, 1092, 1093, 0, - 0, 462, 463, 801, 465, 802, 1094, 467, 468, 1297, - 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, - 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, - 486, 487, 1095, 489, 0, 490, 1299, 492, 493, 494, - 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, - 1096, 0, 0, 0, 0, 0, 0, 1097, 1098, 1099, - 0, 0, 0, 0, 1100, 0, 1101, 3158, 0, 0, - 0, 0, 1102, 1103, 1104, 1105, 1264, 1056, 821, 1057, - 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 1266, 0, 1062, 0, 0, 1267, 130, 131, 0, 132, - 133, 134, 1268, 136, 137, 138, 139, 1063, 1269, 1064, - 1065, 0, 144, 145, 146, 147, 148, 149, 1066, 790, - 150, 151, 152, 153, 1067, 1068, 156, 0, 157, 158, - 159, 160, 791, 0, 1270, 0, 1271, 164, 165, 166, - 167, 168, 1272, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 1273, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 1070, 191, 192, 1071, 194, - 1072, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 1073, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 1074, 222, 223, 224, 225, - 226, 227, 793, 1075, 229, 0, 230, 231, 1076, 233, - 0, 234, 0, 235, 1275, 0, 1276, 238, 239, 1277, - 1278, 242, 0, 243, 0, 1077, 1078, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 1279, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 1280, 269, 270, 271, 272, 273, 274, 1079, - 1080, 0, 1081, 0, 278, 1281, 1282, 281, 1283, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 1284, 291, - 1285, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 1286, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 1083, 1287, 1084, 325, 326, 327, 328, 1085, 329, - 330, 1288, 332, 1086, 795, 334, 1087, 336, 337, 338, - 0, 339, 340, 0, 0, 1088, 342, 343, 0, 0, - 344, 345, 346, 1289, 348, 1290, 797, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 798, 1291, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 1089, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 1292, 404, 405, - 406, 1090, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 1293, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 1294, 431, 432, - 1091, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 1295, 448, 800, 0, 0, - 450, 451, 0, 452, 1296, 454, 455, 456, 457, 458, - 0, 459, 1092, 1093, 0, 0, 462, 463, 801, 465, - 802, 1094, 467, 468, 1297, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 1095, 489, 0, - 490, 1299, 492, 493, 494, 495, 496, 497, 498, 0, - 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 520, 1096, 0, 0, 0, 0, - 0, 0, 1097, 1098, 1099, 0, 0, 0, 0, 1100, - 0, 1101, 0, 0, 0, 0, 0, 1102, 1103, 1104, - 1105, 117, 1056, 821, 1057, 1058, 1059, 1060, 1061, 0, + 0, 118, 119, 120, 121, 122, 123, 124, 125, 3096, + 126, 127, 128, 0, 0, 0, 0, 0, 1062, 0, + 0, 129, 130, 131, 0, 132, 133, 134, 135, 136, + 137, 138, 139, 1063, 141, 1064, 1065, 0, 144, 145, + 146, 147, 148, 149, 1066, 790, 150, 151, 152, 153, + 1067, 1068, 156, 0, 157, 158, 159, 160, 791, 0, + 792, 0, 1069, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, + 179, 180, 3097, 182, 183, 184, 185, 186, 187, 188, + 189, 1070, 191, 192, 1071, 194, 1072, 195, 0, 196, + 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, + 205, 0, 0, 206, 207, 1073, 209, 210, 0, 211, + 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, + 220, 1074, 222, 223, 224, 225, 226, 227, 793, 1075, + 229, 0, 230, 231, 1076, 233, 0, 234, 0, 235, + 236, 0, 237, 238, 239, 240, 241, 242, 0, 243, + 0, 3098, 1078, 246, 247, 0, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 0, 0, 289, 290, 291, 292, 0, 293, 294, + 295, 296, 297, 298, 299, 300, 1082, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 1083, 323, 1084, + 325, 326, 327, 328, 1085, 329, 330, 331, 332, 1086, + 795, 334, 1087, 336, 337, 338, 0, 339, 340, 0, + 0, 1088, 342, 343, 0, 0, 344, 345, 346, 347, + 348, 349, 797, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, + 798, 365, 366, 367, 368, 369, 370, 371, 0, 372, + 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, + 382, 1089, 384, 385, 386, 387, 0, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 0, 401, 402, 403, 404, 405, 3099, 1090, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 0, 430, 431, 432, 1091, 434, 0, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, 447, 448, 800, 0, 0, 450, 451, 0, 452, + 453, 454, 455, 456, 457, 458, 0, 459, 1092, 1093, + 0, 0, 462, 463, 801, 465, 802, 1094, 467, 468, + 803, 470, 471, 472, 473, 474, 0, 0, 475, 476, + 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, + 485, 486, 487, 1095, 489, 0, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, + 520, 1096, 0, 0, 0, 0, 0, 0, 1097, 1098, + 1099, 0, 0, 0, 0, 1100, 0, 3100, 0, 0, + 0, 0, 0, 1102, 1103, 1104, 1105, 117, 1056, 821, + 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, + 0, 0, 0, 1062, 0, 0, 129, 130, 131, 0, + 132, 133, 134, 135, 136, 137, 138, 139, 1063, 141, + 1064, 1065, 0, 144, 145, 146, 147, 148, 149, 1066, + 790, 150, 151, 152, 153, 1067, 1068, 156, 0, 157, + 158, 159, 160, 791, 0, 792, 0, 1069, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 1070, 191, 192, 1071, + 194, 1072, 195, 0, 196, 197, 198, 199, 200, 201, + 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, + 1073, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 1074, 222, 223, 224, + 225, 226, 227, 793, 1075, 229, 0, 230, 231, 1076, + 233, 0, 234, 0, 235, 236, 0, 237, 238, 239, + 240, 241, 242, 0, 243, 0, 1077, 1078, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, + 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 1079, 1080, 0, 1081, 0, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 290, + 291, 292, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 1082, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 1083, 323, 1084, 325, 326, 327, 328, 1085, + 329, 330, 331, 332, 1086, 795, 334, 1087, 336, 337, + 338, 0, 339, 340, 0, 0, 1088, 342, 343, 0, + 0, 344, 345, 346, 347, 348, 349, 797, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, + 0, 0, 0, 362, 363, 798, 365, 366, 367, 368, + 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, + 0, 378, 379, 380, 381, 382, 1089, 384, 385, 386, + 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 0, 401, 402, 403, 404, + 405, 406, 1090, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 0, 430, 431, + 432, 1091, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 447, 448, 800, 0, + 0, 450, 451, 0, 452, 453, 454, 455, 456, 457, + 458, 0, 459, 1092, 1093, 0, 0, 462, 463, 801, + 465, 802, 1094, 467, 468, 803, 470, 471, 472, 473, + 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 487, 1095, 489, + 0, 490, 491, 492, 493, 494, 495, 496, 497, 498, + 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 520, 1096, 0, 0, 0, + 0, 0, 0, 1097, 1098, 1099, 0, 0, 0, 0, + 1100, 0, 1101, 0, 0, 0, 0, 3321, 1102, 1103, + 1104, 1105, 117, 1056, 821, 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 118, 119, 120, 121, 122, 123, 124, 125, 1717, 126, - 127, 128, 0, 0, 0, 0, 0, 1062, 0, 0, - 129, 130, 131, 0, 132, 133, 134, 135, 136, 137, - 138, 139, 1063, 141, 1064, 1065, 0, 144, 145, 146, - 147, 148, 149, 1066, 790, 150, 151, 152, 153, 1067, - 1068, 156, 0, 157, 158, 159, 160, 791, 0, 792, - 0, 1069, 164, 165, 166, 167, 168, 169, 170, 171, - 172, 0, 173, 174, 175, 176, 177, 178, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 1070, 191, 192, 1071, 194, 1072, 195, 0, 196, 197, - 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, - 0, 0, 206, 207, 1073, 209, 210, 0, 211, 212, - 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, - 1074, 222, 223, 224, 225, 226, 227, 793, 1075, 229, - 0, 230, 231, 1076, 233, 0, 234, 0, 235, 236, - 0, 237, 238, 239, 240, 241, 242, 0, 243, 0, - 1077, 1078, 246, 247, 0, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, - 262, 263, 264, 265, 266, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, - 0, 0, 289, 290, 291, 292, 0, 293, 294, 295, - 296, 297, 298, 299, 300, 1082, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 1083, 323, 1084, 325, - 326, 327, 328, 1085, 329, 330, 331, 332, 1086, 795, - 334, 1087, 336, 337, 338, 0, 339, 340, 0, 0, - 1088, 342, 343, 0, 0, 344, 345, 346, 347, 348, - 349, 797, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, 361, 0, 0, 0, 0, 362, 363, 798, - 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, - 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, - 1089, 384, 385, 386, 387, 0, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, - 401, 402, 403, 404, 405, 406, 1090, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, - 429, 0, 430, 431, 432, 1091, 434, 0, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - 447, 448, 800, 0, 0, 450, 451, 0, 452, 453, - 454, 455, 456, 457, 458, 0, 459, 1092, 1093, 0, - 0, 462, 463, 801, 465, 802, 1094, 467, 468, 803, - 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, - 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, - 486, 487, 1095, 489, 0, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, - 1096, 0, 0, 0, 0, 0, 0, 1097, 1098, 1099, - 0, 0, 0, 0, 1100, 0, 1101, 0, 0, 0, - 0, 0, 1102, 1103, 1104, 1105, 117, 1732, 821, 1057, - 1058, 1059, 1733, 1061, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 1734, 126, 127, 128, 0, 0, 0, - 0, 0, 1062, 0, 0, 129, 130, 131, 0, 132, - 133, 134, 135, 136, 137, 138, 139, 1063, 141, 1064, - 1065, 0, 144, 145, 146, 147, 148, 149, 1066, 790, - 150, 151, 152, 153, 1067, 1068, 156, 0, 157, 158, - 159, 160, 791, 0, 792, 0, 1069, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 1070, 191, 192, 1071, 194, - 1072, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 1073, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 1074, 222, 223, 224, 225, - 226, 227, 793, 1075, 229, 0, 230, 231, 1076, 233, - 0, 234, 0, 235, 236, 0, 237, 238, 239, 240, - 241, 242, 0, 243, 0, 1077, 1078, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 1079, - 1080, 0, 1081, 0, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 290, 291, - 292, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 1082, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 1083, 323, 1084, 325, 326, 327, 328, 1085, 329, - 330, 331, 332, 1086, 795, 334, 1087, 336, 337, 338, - 0, 339, 340, 0, 0, 1088, 342, 343, 0, 0, - 344, 345, 346, 347, 348, 349, 797, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 798, 365, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 1089, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 403, 404, 405, - 406, 1090, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 430, 431, 432, - 1091, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 447, 448, 800, 0, 0, - 450, 451, 0, 452, 453, 454, 455, 456, 457, 458, - 0, 459, 1092, 1093, 0, 0, 462, 463, 801, 465, - 802, 1094, 467, 468, 803, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 1095, 489, 0, - 490, 491, 492, 493, 494, 495, 496, 497, 498, 0, - 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 520, 1096, 0, 0, 0, 0, - 0, 0, 1097, 1098, 1099, 0, 0, 0, 0, 1100, - 0, 1101, 0, 0, 0, 0, 0, 1102, 1103, 1104, - 1105, 117, 1056, 821, 1057, 1058, 1059, 1060, 1061, 0, + 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, + 126, 127, 128, 0, 0, 0, 0, 0, 1062, 0, + 0, 129, 130, 131, 0, 132, 133, 134, 135, 136, + 137, 138, 139, 1063, 141, 1064, 1065, 0, 144, 145, + 146, 147, 148, 149, 1066, 790, 150, 151, 152, 153, + 1067, 1068, 156, 0, 157, 158, 159, 160, 791, 0, + 792, 0, 1069, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 1070, 191, 192, 1071, 194, 1072, 195, 0, 196, + 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, + 205, 0, 0, 206, 207, 1073, 209, 210, 0, 211, + 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, + 220, 1074, 222, 223, 224, 225, 226, 227, 793, 1075, + 229, 0, 230, 231, 1076, 233, 0, 234, 0, 235, + 236, 0, 237, 238, 239, 240, 241, 242, 0, 243, + 0, 1077, 1078, 246, 247, 0, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 0, 0, 289, 290, 291, 292, 0, 293, 294, + 295, 296, 297, 298, 299, 300, 1082, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 1083, 323, 1084, + 325, 326, 327, 328, 1085, 329, 330, 331, 332, 1086, + 795, 334, 1087, 336, 337, 338, 0, 339, 340, 0, + 0, 1088, 342, 343, 0, 0, 344, 345, 346, 347, + 348, 349, 797, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, + 798, 365, 366, 367, 368, 369, 370, 371, 0, 372, + 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, + 382, 1089, 384, 385, 386, 387, 0, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 0, 401, 402, 403, 404, 405, 406, 1090, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 0, 430, 431, 432, 1091, 434, 0, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, 447, 448, 800, 0, 0, 450, 451, 0, 452, + 453, 454, 455, 456, 457, 458, 0, 459, 1092, 1093, + 0, 0, 462, 463, 801, 465, 802, 1094, 467, 468, + 803, 470, 471, 472, 473, 474, 0, 0, 475, 476, + 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, + 485, 486, 487, 1095, 489, 0, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, + 520, 1096, 0, 0, 0, 0, 0, 0, 1097, 1098, + 1099, 0, 0, 0, 0, 1100, 0, 1101, 0, 0, + 0, 0, 0, 1102, 1103, 1104, 1105, 117, 1056, 821, + 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, + 0, 0, 0, 1062, 0, 0, 129, 130, 131, 0, + 132, 133, 134, 135, 136, 137, 138, 139, 1063, 141, + 1064, 1065, 0, 144, 145, 146, 147, 148, 149, 1066, + 790, 150, 151, 152, 153, 1067, 1068, 156, 0, 157, + 158, 159, 160, 791, 0, 792, 0, 1069, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 1070, 191, 192, 1071, + 194, 1072, 195, 0, 196, 197, 198, 199, 200, 201, + 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, + 1073, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 1074, 222, 223, 224, + 225, 226, 227, 793, 1075, 229, 0, 230, 231, 1076, + 233, 0, 234, 0, 235, 236, 0, 237, 238, 239, + 240, 241, 242, 0, 243, 0, 1077, 1078, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, + 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 1079, 1080, 0, 1081, 0, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 290, + 291, 292, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 1082, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 1083, 323, 1084, 325, 326, 327, 328, 1085, + 329, 330, 331, 332, 1086, 795, 334, 1087, 336, 337, + 338, 0, 339, 340, 0, 0, 1088, 342, 343, 0, + 0, 344, 345, 346, 347, 348, 349, 797, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, + 0, 0, 0, 362, 363, 798, 365, 366, 367, 368, + 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, + 0, 378, 379, 380, 381, 382, 1089, 384, 385, 386, + 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 0, 401, 402, 403, 404, + 405, 406, 1090, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 0, 430, 431, + 432, 1091, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 447, 448, 800, 0, + 0, 450, 451, 0, 452, 453, 454, 455, 456, 457, + 458, 0, 459, 1092, 1093, 0, 0, 462, 463, 801, + 465, 802, 1094, 467, 468, 803, 470, 471, 472, 473, + 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 487, 1095, 489, + 0, 490, 491, 492, 493, 494, 495, 496, 497, 498, + 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 520, 1096, 0, 0, 0, + 0, 0, 0, 1737, 1738, 1099, 0, 0, 0, 0, + 1100, 0, 1101, 0, 0, 0, 0, 0, 1102, 1103, + 1104, 1105, 117, 2238, 821, 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, - 127, 128, 0, 0, 0, 0, 0, 1062, 0, 0, - 129, 130, 131, 0, 132, 133, 134, 135, 136, 137, - 138, 139, 1063, 141, 1064, 1065, 0, 144, 145, 146, - 147, 148, 149, 1066, 790, 150, 151, 152, 153, 1067, - 1068, 156, 0, 157, 158, 159, 160, 791, 0, 792, - 0, 1069, 164, 165, 166, 167, 168, 169, 170, 171, - 172, 0, 173, 174, 175, 176, 177, 178, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 1070, 191, 192, 1071, 194, 1072, 195, 0, 196, 197, - 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, - 0, 0, 206, 207, 1073, 209, 210, 0, 211, 212, - 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, - 1074, 222, 223, 224, 225, 226, 227, 793, 1075, 229, - 0, 230, 231, 1076, 233, 0, 234, 0, 235, 236, - 1449, 237, 238, 239, 240, 241, 242, 0, 243, 0, - 1077, 1078, 246, 247, 0, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, - 262, 263, 264, 265, 266, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, - 0, 0, 289, 290, 291, 292, 0, 293, 294, 295, - 296, 297, 298, 299, 300, 1082, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 1083, 323, 1084, 325, - 326, 327, 328, 1085, 329, 330, 331, 332, 1086, 795, - 334, 1087, 336, 337, 338, 0, 339, 340, 0, 0, - 1088, 342, 343, 0, 0, 344, 345, 346, 347, 348, - 349, 797, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, 361, 0, 0, 0, 0, 362, 363, 798, - 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, - 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, - 1089, 384, 385, 386, 387, 0, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, - 401, 402, 403, 404, 405, 406, 1090, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, - 429, 0, 430, 431, 432, 1091, 434, 0, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - 447, 448, 800, 0, 0, 450, 451, 0, 452, 453, - 454, 455, 456, 457, 458, 0, 459, 1092, 1093, 0, - 0, 462, 463, 801, 465, 802, 1094, 467, 468, 803, - 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, - 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, - 486, 487, 1095, 489, 0, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, - 1096, 0, 0, 0, 0, 0, 0, 1097, 1098, 1099, - 0, 0, 0, 0, 1100, 0, 1101, 0, 0, 0, - 0, 0, 1102, 1103, 1104, 1105, 117, 1056, 821, 1057, - 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 0, 0, 1062, 0, 0, 129, 130, 131, 0, 132, - 133, 134, 135, 136, 137, 138, 139, 1063, 141, 1064, - 1065, 0, 144, 145, 146, 147, 148, 149, 1066, 790, - 150, 151, 152, 153, 1067, 1068, 156, 0, 157, 158, - 159, 160, 791, 0, 792, 0, 1069, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 1070, 191, 192, 1071, 194, - 1072, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 1073, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 1074, 222, 223, 224, 225, - 226, 227, 793, 1075, 229, 0, 230, 231, 1076, 233, - 0, 234, 0, 235, 236, 0, 237, 238, 239, 240, - 241, 242, 0, 243, 0, 1077, 1078, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 1079, - 1080, 0, 1081, 0, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 290, 291, - 292, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 1082, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 1083, 323, 1084, 325, 326, 327, 328, 1085, 329, - 330, 331, 332, 1086, 795, 334, 1087, 336, 337, 338, - 0, 339, 340, 0, 0, 1088, 342, 343, 0, 0, - 344, 345, 346, 347, 348, 349, 797, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 798, 365, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 1089, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 403, 404, 405, - 406, 1090, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 430, 431, 432, - 1091, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 447, 448, 800, 0, 0, - 450, 451, 0, 452, 453, 454, 455, 456, 457, 458, - 0, 459, 1092, 1093, 0, 0, 462, 463, 801, 465, - 802, 1094, 467, 468, 803, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 1095, 489, 0, - 490, 491, 492, 493, 494, 495, 496, 497, 498, 0, - 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 520, 1096, 0, 0, 0, 0, - 0, 0, 1097, 1098, 1099, 0, 0, 0, 0, 1100, - 0, 1101, 2094, 0, 0, 0, 0, 1102, 1103, 1104, - 1105, 117, 1056, 821, 1057, 1058, 1059, 1060, 1061, 0, + 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, + 126, 127, 128, 0, 0, 0, 0, 0, 1062, 0, + 0, 129, 130, 131, 0, 132, 133, 134, 135, 136, + 137, 138, 139, 1063, 141, 1064, 1065, 0, 144, 145, + 146, 147, 148, 149, 1066, 790, 150, 151, 152, 153, + 1067, 1068, 156, 0, 157, 158, 159, 160, 791, 0, + 792, 0, 1069, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 1070, 191, 192, 1071, 194, 1072, 195, 0, 196, + 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, + 205, 0, 0, 206, 207, 1073, 209, 210, 0, 211, + 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, + 220, 1074, 222, 223, 224, 225, 226, 227, 793, 1075, + 229, 0, 230, 231, 1076, 233, 0, 234, 0, 235, + 236, 0, 237, 238, 239, 240, 241, 242, 0, 243, + 0, 1077, 1078, 246, 247, 0, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 0, 0, 289, 290, 291, 292, 0, 293, 294, + 295, 296, 297, 298, 299, 300, 1082, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 1083, 323, 1084, + 325, 326, 327, 328, 1085, 329, 330, 331, 332, 1086, + 795, 334, 1087, 336, 337, 338, 0, 339, 340, 0, + 0, 1088, 342, 343, 0, 0, 344, 345, 346, 347, + 348, 349, 797, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, + 798, 365, 366, 367, 368, 369, 370, 371, 0, 372, + 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, + 382, 1089, 384, 385, 386, 387, 0, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 0, 401, 402, 403, 404, 405, 406, 1090, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 0, 430, 431, 432, 1091, 434, 0, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, 447, 448, 800, 0, 0, 450, 451, 0, 452, + 453, 454, 455, 456, 457, 458, 0, 459, 1092, 1093, + 0, 0, 462, 463, 801, 465, 802, 1094, 467, 468, + 803, 470, 471, 472, 473, 474, 0, 0, 475, 476, + 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, + 485, 486, 487, 1095, 489, 0, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, + 520, 1096, 0, 0, 0, 0, 0, 0, 1097, 1098, + 1099, 0, 0, 0, 0, 1100, 0, 1101, 0, 0, + 0, 0, 0, 1102, 1103, 1104, 1105, 117, 1056, 821, + 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, + 0, 0, 0, 1062, 0, 0, 129, 130, 131, 0, + 132, 133, 134, 135, 136, 137, 138, 139, 1063, 141, + 1064, 1065, 0, 144, 145, 146, 147, 148, 149, 1066, + 790, 150, 151, 152, 153, 1067, 1068, 156, 0, 157, + 158, 159, 160, 791, 0, 792, 0, 1069, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 1070, 191, 192, 1071, + 194, 1072, 195, 0, 196, 197, 198, 199, 200, 201, + 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, + 1073, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 1074, 222, 223, 224, + 225, 226, 227, 793, 1075, 229, 0, 230, 231, 1076, + 233, 0, 234, 0, 235, 236, 0, 237, 238, 239, + 240, 241, 242, 0, 243, 0, 1077, 1078, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, + 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 1079, 1080, 0, 1081, 0, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 290, + 291, 292, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 1082, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 1083, 323, 1084, 325, 326, 327, 328, 1085, + 329, 330, 331, 332, 1086, 795, 334, 1087, 336, 337, + 338, 0, 339, 340, 0, 0, 1088, 342, 343, 0, + 0, 344, 345, 346, 347, 348, 349, 797, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, + 0, 0, 0, 362, 363, 798, 365, 366, 367, 368, + 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, + 0, 378, 379, 380, 381, 382, 1089, 384, 385, 386, + 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 0, 401, 402, 403, 404, + 405, 406, 1090, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 0, 430, 431, + 432, 1091, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 447, 448, 800, 0, + 0, 450, 451, 0, 452, 453, 454, 455, 456, 457, + 458, 0, 459, 1092, 1093, 0, 0, 462, 463, 801, + 465, 802, 1094, 467, 468, 803, 470, 471, 472, 473, + 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 487, 1095, 489, + 0, 490, 491, 492, 493, 494, 495, 496, 497, 498, + 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 520, 1096, 0, 0, 0, + 0, 0, 0, 1097, 2325, 1099, 0, 0, 0, 0, + 1100, 0, 1101, 0, 0, 0, 0, 0, 1102, 1103, + 1104, 1105, 117, 1056, 821, 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, - 127, 128, 0, 0, 0, 0, 0, 1062, 0, 0, - 129, 130, 131, 0, 132, 133, 134, 135, 136, 137, - 138, 139, 1063, 141, 1064, 1065, 0, 144, 145, 146, - 147, 148, 149, 1066, 790, 150, 151, 152, 153, 1067, - 1068, 156, 0, 157, 158, 159, 160, 791, 0, 792, - 0, 1069, 164, 165, 166, 167, 168, 169, 170, 171, - 172, 0, 173, 174, 175, 176, 177, 178, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 1070, 191, 192, 1071, 194, 1072, 195, 0, 196, 197, - 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, - 0, 0, 206, 207, 1073, 209, 210, 0, 211, 212, - 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, - 1074, 222, 223, 224, 225, 226, 227, 793, 1075, 229, - 0, 230, 231, 1076, 233, 0, 234, 0, 235, 236, - 0, 237, 238, 239, 240, 241, 242, 0, 243, 0, - 1077, 1078, 246, 247, 0, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, - 262, 263, 264, 265, 266, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, - 0, 0, 289, 290, 291, 292, 0, 293, 294, 295, - 296, 297, 298, 299, 300, 1082, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 1083, 323, 1084, 325, - 326, 327, 328, 1085, 329, 330, 331, 332, 1086, 795, - 334, 1087, 336, 337, 338, 0, 339, 340, 0, 0, - 1088, 342, 343, 0, 0, 344, 345, 346, 347, 348, - 349, 797, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, 361, 0, 0, 0, 0, 362, 363, 798, - 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, - 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, - 1089, 384, 385, 386, 387, 0, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, - 401, 402, 403, 404, 405, 406, 1090, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, - 429, 0, 430, 431, 432, 1091, 434, 0, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - 447, 448, 800, 0, 0, 450, 451, 0, 452, 453, - 454, 455, 456, 457, 458, 0, 459, 1092, 1093, 0, - 0, 462, 463, 801, 465, 802, 1094, 467, 468, 803, - 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, - 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, - 486, 487, 1095, 489, 0, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, - 1096, 0, 0, 0, 0, 0, 0, 1097, 1098, 1099, - 0, 0, 0, 0, 1100, 0, 1101, 0, 0, 0, - 0, 2692, 1102, 1103, 1104, 1105, 117, 1056, 821, 1057, - 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 0, 0, 1062, 0, 0, 129, 130, 131, 0, 132, - 133, 134, 135, 136, 137, 138, 139, 1063, 141, 1064, - 1065, 0, 144, 145, 146, 147, 148, 149, 1066, 790, - 150, 151, 152, 153, 1067, 1068, 156, 0, 157, 158, - 159, 160, 791, 0, 792, 0, 1069, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 1070, 191, 192, 1071, 194, - 1072, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 1073, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 1074, 222, 223, 224, 225, - 226, 227, 793, 1075, 229, 0, 230, 231, 1076, 233, - 0, 234, 0, 235, 236, 0, 237, 238, 239, 240, - 241, 242, 0, 243, 0, 1077, 1078, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 1079, - 1080, 0, 1081, 0, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 290, 291, - 292, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 1082, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 1083, 323, 1084, 325, 326, 327, 328, 1085, 329, - 330, 331, 332, 1086, 795, 334, 1087, 336, 337, 338, - 0, 339, 340, 0, 0, 1088, 342, 343, 0, 0, - 344, 345, 346, 347, 348, 349, 797, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 798, 365, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 1089, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 403, 404, 405, - 406, 1090, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 430, 431, 432, - 1091, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 447, 448, 800, 0, 0, - 450, 451, 2751, 452, 453, 454, 455, 456, 457, 458, - 0, 459, 1092, 1093, 0, 0, 462, 463, 801, 465, - 802, 1094, 467, 468, 803, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 1095, 489, 0, - 490, 491, 492, 493, 494, 495, 496, 497, 498, 0, - 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 520, 1096, 0, 0, 0, 0, - 0, 0, 1097, 1098, 1099, 0, 0, 0, 0, 1100, - 0, 1101, 0, 0, 0, 0, 0, 1102, 1103, 1104, - 1105, 117, 1056, 821, 1057, 1058, 1059, 1060, 1061, 0, + 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, + 126, 127, 128, 0, 0, 0, 0, 0, 1062, 0, + 0, 129, 130, 131, 0, 132, 133, 134, 135, 136, + 137, 138, 139, 1063, 141, 1064, 1065, 0, 144, 145, + 146, 147, 148, 149, 1066, 790, 150, 151, 152, 153, + 1067, 1068, 156, 0, 157, 158, 159, 160, 791, 0, + 792, 0, 1069, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 1070, 191, 192, 1071, 194, 1072, 195, 0, 196, + 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, + 205, 0, 0, 206, 207, 1073, 209, 210, 0, 211, + 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, + 220, 1074, 222, 223, 224, 225, 226, 227, 793, 1075, + 229, 0, 230, 231, 1076, 233, 0, 234, 0, 235, + 236, 0, 237, 238, 239, 240, 241, 242, 0, 243, + 0, 1077, 1078, 246, 247, 0, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 0, 0, 289, 290, 291, 292, 0, 293, 294, + 295, 296, 297, 298, 299, 300, 1082, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 1083, 323, 1084, + 325, 326, 327, 328, 1085, 329, 330, 331, 332, 1086, + 795, 334, 1087, 336, 337, 338, 0, 339, 340, 0, + 0, 1088, 342, 343, 0, 0, 344, 345, 346, 347, + 348, 349, 797, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, + 798, 365, 366, 367, 368, 369, 370, 371, 0, 372, + 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, + 382, 1089, 384, 385, 386, 387, 0, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 0, 401, 402, 403, 404, 405, 406, 1090, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 0, 430, 431, 432, 1091, 434, 0, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, 447, 448, 800, 0, 0, 450, 451, 0, 452, + 453, 454, 455, 456, 457, 458, 0, 459, 1092, 1093, + 0, 0, 462, 463, 801, 465, 802, 1094, 467, 468, + 803, 470, 471, 472, 473, 474, 0, 0, 475, 476, + 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, + 485, 486, 487, 1095, 489, 0, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, + 520, 1096, 0, 0, 0, 0, 0, 0, 1097, 1098, + 1099, 0, 0, 0, 0, 1100, 0, 2547, 0, 0, + 0, 0, 0, 1102, 1103, 1104, 1105, 117, 1056, 821, + 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, + 0, 0, 0, 1062, 0, 0, 129, 130, 131, 0, + 132, 133, 134, 135, 136, 137, 138, 139, 1063, 141, + 1064, 1065, 0, 144, 145, 146, 147, 148, 149, 1066, + 790, 150, 151, 152, 153, 1067, 1068, 156, 0, 157, + 158, 159, 160, 791, 0, 792, 0, 1069, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 1070, 191, 192, 1071, + 194, 1072, 195, 0, 196, 197, 198, 199, 200, 201, + 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, + 1073, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 1074, 222, 223, 224, + 225, 226, 227, 793, 1075, 229, 0, 230, 231, 1076, + 233, 0, 234, 0, 235, 236, 0, 237, 238, 239, + 240, 241, 242, 0, 243, 0, 1077, 1078, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, + 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 1079, 1080, 0, 1081, 0, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 290, + 291, 292, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 1082, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 1083, 323, 1084, 325, 326, 327, 328, 1085, + 329, 330, 331, 332, 1086, 795, 334, 1087, 336, 337, + 338, 0, 339, 340, 0, 0, 1088, 342, 343, 0, + 0, 344, 345, 346, 347, 348, 349, 797, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, + 0, 0, 0, 362, 363, 798, 365, 366, 367, 368, + 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, + 0, 378, 379, 380, 381, 382, 1089, 384, 385, 386, + 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 0, 401, 402, 403, 404, + 405, 406, 1090, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 0, 430, 431, + 432, 1091, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 447, 448, 800, 0, + 0, 450, 451, 0, 452, 453, 454, 455, 456, 457, + 458, 0, 459, 1092, 1093, 0, 0, 462, 463, 801, + 465, 802, 1094, 467, 468, 803, 470, 471, 472, 473, + 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 487, 1095, 489, + 0, 490, 491, 492, 493, 494, 495, 496, 497, 498, + 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 520, 1096, 0, 0, 0, + 0, 0, 0, 1097, 3157, 1099, 0, 0, 0, 0, + 1100, 0, 1101, 0, 0, 0, 0, 0, 1102, 1103, + 1104, 1105, 117, 1056, 821, 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, - 127, 128, 0, 0, 0, 0, 0, 1062, 0, 0, - 129, 130, 131, 0, 132, 133, 134, 135, 136, 137, - 138, 139, 1063, 141, 1064, 1065, 0, 144, 145, 146, - 147, 148, 149, 1066, 790, 150, 151, 152, 153, 1067, - 1068, 156, 0, 157, 158, 159, 160, 791, 0, 792, - 0, 1069, 164, 165, 166, 167, 168, 169, 170, 171, - 172, 0, 173, 174, 175, 176, 177, 178, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 1070, 191, 192, 1071, 194, 1072, 195, 0, 196, 197, - 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, - 0, 0, 206, 207, 1073, 209, 210, 0, 211, 212, - 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, - 1074, 222, 223, 224, 225, 226, 227, 793, 1075, 229, - 0, 230, 231, 1076, 233, 0, 234, 0, 235, 236, - 0, 237, 238, 239, 240, 241, 242, 0, 243, 0, - 1077, 1078, 246, 247, 0, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, - 262, 263, 264, 265, 266, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, - 0, 0, 289, 290, 291, 292, 0, 293, 294, 295, - 296, 297, 298, 299, 300, 1082, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 1083, 323, 1084, 325, - 326, 327, 328, 1085, 329, 330, 331, 332, 1086, 795, - 334, 1087, 336, 337, 338, 0, 339, 340, 0, 0, - 1088, 342, 343, 0, 0, 344, 345, 346, 347, 348, - 349, 797, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, 361, 0, 0, 0, 0, 362, 363, 798, - 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, - 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, - 1089, 384, 385, 386, 387, 0, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, - 401, 402, 403, 404, 405, 406, 1090, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, - 429, 0, 430, 431, 432, 1091, 434, 0, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - 447, 448, 800, 0, 0, 450, 451, 0, 452, 453, - 454, 455, 456, 457, 458, 0, 459, 1092, 1093, 0, - 0, 462, 463, 801, 465, 802, 1094, 467, 468, 803, - 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, - 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, - 486, 487, 1095, 489, 0, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 0, 2877, 499, 0, 0, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, - 1096, 0, 0, 0, 0, 0, 0, 1097, 1098, 1099, - 0, 0, 0, 0, 1100, 0, 1101, 0, 0, 0, - 0, 0, 1102, 1103, 1104, 1105, 117, 1056, 821, 1057, - 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 3095, 126, 127, 128, 0, 0, 0, - 0, 0, 1062, 0, 0, 129, 130, 131, 0, 132, - 133, 134, 135, 136, 137, 138, 139, 1063, 141, 1064, - 1065, 0, 144, 145, 146, 147, 148, 149, 1066, 790, - 150, 151, 152, 153, 1067, 1068, 156, 0, 157, 158, - 159, 160, 791, 0, 792, 0, 1069, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 179, 180, 3096, 182, 183, 184, - 185, 186, 187, 188, 189, 1070, 191, 192, 1071, 194, - 1072, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 1073, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 1074, 222, 223, 224, 225, - 226, 227, 793, 1075, 229, 0, 230, 231, 1076, 233, - 0, 234, 0, 235, 236, 0, 237, 238, 239, 240, - 241, 242, 0, 243, 0, 3097, 1078, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 1079, - 1080, 0, 1081, 0, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 290, 291, - 292, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 1082, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 1083, 323, 1084, 325, 326, 327, 328, 1085, 329, - 330, 331, 332, 1086, 795, 334, 1087, 336, 337, 338, - 0, 339, 340, 0, 0, 1088, 342, 343, 0, 0, - 344, 345, 346, 347, 348, 349, 797, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 798, 365, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 1089, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 403, 404, 405, - 3098, 1090, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 430, 431, 432, - 1091, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 447, 448, 800, 0, 0, - 450, 451, 0, 452, 453, 454, 455, 456, 457, 458, - 0, 459, 1092, 1093, 0, 0, 462, 463, 801, 465, - 802, 1094, 467, 468, 803, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 1095, 489, 0, - 490, 491, 492, 493, 494, 495, 496, 497, 498, 0, - 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 520, 1096, 0, 0, 0, 0, - 0, 0, 1097, 1098, 1099, 0, 0, 0, 0, 1100, - 0, 3099, 0, 0, 0, 0, 0, 1102, 1103, 1104, - 1105, 117, 1056, 821, 1057, 1058, 1059, 1060, 1061, 0, + 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, + 126, 127, 128, 0, 0, 0, 0, 0, 1062, 0, + 0, 129, 130, 131, 0, 132, 133, 134, 135, 136, + 137, 138, 139, 1063, 141, 1064, 1065, 0, 144, 145, + 146, 147, 148, 149, 1066, 790, 150, 151, 152, 153, + 1067, 1068, 156, 0, 157, 158, 159, 160, 791, 0, + 792, 0, 1069, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, + 179, 180, 3097, 182, 183, 184, 185, 186, 187, 188, + 189, 1070, 191, 192, 1071, 194, 1072, 195, 0, 196, + 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, + 205, 0, 0, 206, 207, 1073, 209, 210, 0, 211, + 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, + 220, 1074, 222, 223, 224, 225, 226, 227, 793, 1075, + 229, 0, 230, 231, 1076, 233, 0, 234, 0, 235, + 236, 0, 237, 238, 239, 240, 241, 242, 0, 243, + 0, 3098, 1078, 246, 247, 0, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 0, 0, 289, 290, 291, 292, 0, 293, 294, + 295, 296, 297, 298, 299, 300, 1082, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 1083, 323, 1084, + 325, 326, 327, 328, 1085, 329, 330, 331, 332, 1086, + 795, 334, 1087, 336, 337, 338, 0, 339, 340, 0, + 0, 1088, 342, 343, 0, 0, 344, 345, 346, 347, + 348, 349, 797, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, + 798, 365, 366, 367, 368, 369, 370, 371, 0, 372, + 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, + 382, 1089, 384, 385, 386, 387, 0, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 0, 401, 402, 403, 404, 405, 3099, 1090, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 0, 430, 431, 432, 1091, 434, 0, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, 447, 448, 800, 0, 0, 450, 451, 0, 452, + 453, 454, 455, 456, 457, 458, 0, 459, 1092, 1093, + 0, 0, 462, 463, 801, 465, 802, 1094, 467, 468, + 803, 470, 471, 472, 473, 474, 0, 0, 475, 476, + 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, + 485, 486, 487, 1095, 489, 0, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, + 520, 1096, 0, 0, 0, 0, 0, 0, 1097, 1098, + 1099, 0, 0, 0, 0, 1100, 0, 3100, 0, 0, + 0, 0, 0, 1102, 1103, 1104, 1105, 117, 1056, 821, + 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, + 0, 0, 0, 1062, 0, 0, 129, 130, 131, 0, + 132, 133, 134, 135, 136, 137, 138, 3565, 1063, 141, + 1064, 1065, 0, 144, 145, 146, 147, 148, 149, 1066, + 790, 150, 151, 152, 153, 1067, 1068, 156, 0, 157, + 158, 159, 160, 791, 0, 792, 0, 1069, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 179, 180, 181, 3566, 183, + 184, 185, 186, 187, 188, 189, 1070, 191, 192, 1071, + 194, 1072, 195, 0, 196, 197, 198, 199, 200, 201, + 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, + 1073, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 1074, 222, 223, 224, + 225, 226, 227, 793, 1075, 229, 0, 230, 231, 1076, + 233, 0, 234, 0, 235, 236, 0, 237, 238, 239, + 240, 241, 242, 0, 243, 0, 1077, 1078, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, + 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 1079, 1080, 0, 1081, 0, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 290, + 291, 292, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 1082, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 1083, 323, 1084, 325, 326, 327, 328, 1085, + 329, 330, 331, 332, 1086, 795, 334, 1087, 336, 337, + 338, 0, 339, 340, 0, 0, 1088, 342, 343, 0, + 0, 344, 345, 346, 347, 348, 349, 797, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, + 0, 0, 0, 362, 363, 798, 365, 366, 367, 368, + 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, + 0, 378, 379, 380, 381, 382, 1089, 384, 385, 386, + 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 0, 401, 402, 403, 404, + 405, 406, 1090, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 0, 430, 431, + 432, 1091, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 447, 448, 800, 0, + 0, 450, 451, 0, 452, 453, 454, 455, 456, 457, + 458, 0, 459, 1092, 1093, 0, 0, 462, 463, 801, + 465, 802, 1094, 467, 468, 803, 470, 471, 3567, 473, + 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 487, 1095, 489, + 0, 490, 491, 492, 493, 494, 495, 496, 497, 498, + 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 520, 1096, 0, 0, 0, + 0, 0, 0, 1097, 1098, 1099, 0, 0, 0, 0, + 1100, 0, 1101, 0, 0, 0, 0, 0, 1102, 1103, + 1104, 1105, 117, 1056, 821, 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, - 127, 128, 0, 0, 0, 0, 0, 1062, 0, 0, - 129, 130, 131, 0, 132, 133, 134, 135, 136, 137, - 138, 139, 1063, 141, 1064, 1065, 0, 144, 145, 146, - 147, 148, 149, 1066, 790, 150, 151, 152, 153, 1067, - 1068, 156, 0, 157, 158, 159, 160, 791, 0, 792, - 0, 1069, 164, 165, 166, 167, 168, 169, 170, 171, - 172, 0, 173, 174, 175, 176, 177, 178, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 1070, 191, 192, 1071, 194, 1072, 195, 0, 196, 197, - 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, - 0, 0, 206, 207, 1073, 209, 210, 0, 211, 212, - 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, - 1074, 222, 223, 224, 225, 226, 227, 793, 1075, 229, - 0, 230, 231, 1076, 233, 0, 234, 0, 235, 236, - 0, 237, 238, 239, 240, 241, 242, 0, 243, 0, - 1077, 1078, 246, 247, 0, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, - 262, 263, 264, 265, 266, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, - 0, 0, 289, 290, 291, 292, 0, 293, 294, 295, - 296, 297, 298, 299, 300, 1082, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 1083, 323, 1084, 325, - 326, 327, 328, 1085, 329, 330, 331, 332, 1086, 795, - 334, 1087, 336, 337, 338, 0, 339, 340, 0, 0, - 1088, 342, 343, 0, 0, 344, 345, 346, 347, 348, - 349, 797, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, 361, 0, 0, 0, 0, 362, 363, 798, - 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, - 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, - 1089, 384, 385, 386, 387, 0, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, - 401, 402, 403, 404, 405, 406, 1090, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, - 429, 0, 430, 431, 432, 1091, 434, 0, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - 447, 448, 800, 0, 0, 450, 451, 0, 452, 453, - 454, 455, 456, 457, 458, 0, 459, 1092, 1093, 0, - 0, 462, 463, 801, 465, 802, 1094, 467, 468, 803, - 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, - 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, - 486, 487, 1095, 489, 0, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, - 1096, 0, 0, 0, 0, 0, 0, 1097, 1098, 1099, - 0, 0, 0, 0, 1100, 0, 1101, 0, 0, 0, - 0, 3320, 1102, 1103, 1104, 1105, 117, 1056, 821, 1057, - 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 0, 0, 1062, 0, 0, 129, 130, 131, 0, 132, - 133, 134, 135, 136, 137, 138, 139, 1063, 141, 1064, - 1065, 0, 144, 145, 146, 147, 148, 149, 1066, 790, - 150, 151, 152, 153, 1067, 1068, 156, 0, 157, 158, - 159, 160, 791, 0, 792, 0, 1069, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 1070, 191, 192, 1071, 194, - 1072, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 1073, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 1074, 222, 223, 224, 225, - 226, 227, 793, 1075, 229, 0, 230, 231, 1076, 233, - 0, 234, 0, 235, 236, 0, 237, 238, 239, 240, - 241, 242, 0, 243, 0, 1077, 1078, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 1079, - 1080, 0, 1081, 0, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 290, 291, - 292, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 1082, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 1083, 323, 1084, 325, 326, 327, 328, 1085, 329, - 330, 331, 332, 1086, 795, 334, 1087, 336, 337, 338, - 0, 339, 340, 0, 0, 1088, 342, 343, 0, 0, - 344, 345, 346, 347, 348, 349, 797, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 798, 365, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 1089, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 403, 404, 405, - 406, 1090, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 430, 431, 432, - 1091, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 447, 448, 800, 0, 0, - 450, 451, 0, 452, 453, 454, 455, 456, 457, 458, - 0, 459, 1092, 1093, 0, 0, 462, 463, 801, 465, - 802, 1094, 467, 468, 803, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 1095, 489, 0, - 490, 491, 492, 493, 494, 495, 496, 497, 498, 0, - 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 520, 1096, 0, 0, 0, 0, - 0, 0, 1097, 1098, 1099, 0, 0, 0, 0, 1100, - 0, 1101, 0, 0, 0, 0, 0, 1102, 1103, 1104, - 1105, 117, 1056, 821, 1057, 1058, 1059, 1060, 1061, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, - 127, 128, 0, 0, 0, 0, 0, 1062, 0, 0, - 129, 130, 131, 0, 132, 133, 134, 135, 136, 137, - 138, 139, 1063, 141, 1064, 1065, 0, 144, 145, 146, - 147, 148, 149, 1066, 790, 150, 151, 152, 153, 1067, - 1068, 156, 0, 157, 158, 159, 160, 791, 0, 792, - 0, 1069, 164, 165, 166, 167, 168, 169, 170, 171, - 172, 0, 173, 174, 175, 176, 177, 178, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 1070, 191, 192, 1071, 194, 1072, 195, 0, 196, 197, - 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, - 0, 0, 206, 207, 1073, 209, 210, 0, 211, 212, - 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, - 1074, 222, 223, 224, 225, 226, 227, 793, 1075, 229, - 0, 230, 231, 1076, 233, 0, 234, 0, 235, 236, - 0, 237, 238, 239, 240, 241, 242, 0, 243, 0, - 1077, 1078, 246, 247, 0, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, - 262, 263, 264, 265, 266, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, - 0, 0, 289, 290, 291, 292, 0, 293, 294, 295, - 296, 297, 298, 299, 300, 1082, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 1083, 323, 1084, 325, - 326, 327, 328, 1085, 329, 330, 331, 332, 1086, 795, - 334, 1087, 336, 337, 338, 0, 339, 340, 0, 0, - 1088, 342, 343, 0, 0, 344, 345, 346, 347, 348, - 349, 797, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, 361, 0, 0, 0, 0, 362, 363, 798, - 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, - 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, - 1089, 384, 385, 386, 387, 0, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, - 401, 402, 403, 404, 405, 406, 1090, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, - 429, 0, 430, 431, 432, 1091, 434, 0, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - 447, 448, 800, 0, 0, 450, 451, 0, 452, 453, - 454, 455, 456, 457, 458, 0, 459, 1092, 1093, 0, - 0, 462, 463, 801, 465, 802, 1094, 467, 468, 803, - 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, - 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, - 486, 487, 1095, 489, 0, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, - 1096, 0, 0, 0, 0, 0, 0, 1737, 1738, 1099, - 0, 0, 0, 0, 1100, 0, 1101, 0, 0, 0, - 0, 0, 1102, 1103, 1104, 1105, 117, 2236, 821, 1057, - 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 0, 0, 1062, 0, 0, 129, 130, 131, 0, 132, - 133, 134, 135, 136, 137, 138, 139, 1063, 141, 1064, - 1065, 0, 144, 145, 146, 147, 148, 149, 1066, 790, - 150, 151, 152, 153, 1067, 1068, 156, 0, 157, 158, - 159, 160, 791, 0, 792, 0, 1069, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 1070, 191, 192, 1071, 194, - 1072, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 1073, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 1074, 222, 223, 224, 225, - 226, 227, 793, 1075, 229, 0, 230, 231, 1076, 233, - 0, 234, 0, 235, 236, 0, 237, 238, 239, 240, - 241, 242, 0, 243, 0, 1077, 1078, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 1079, - 1080, 0, 1081, 0, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 290, 291, - 292, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 1082, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 1083, 323, 1084, 325, 326, 327, 328, 1085, 329, - 330, 331, 332, 1086, 795, 334, 1087, 336, 337, 338, - 0, 339, 340, 0, 0, 1088, 342, 343, 0, 0, - 344, 345, 346, 347, 348, 349, 797, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 798, 365, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 1089, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 403, 404, 405, - 406, 1090, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 430, 431, 432, - 1091, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 447, 448, 800, 0, 0, - 450, 451, 0, 452, 453, 454, 455, 456, 457, 458, - 0, 459, 1092, 1093, 0, 0, 462, 463, 801, 465, - 802, 1094, 467, 468, 803, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 1095, 489, 0, - 490, 491, 492, 493, 494, 495, 496, 497, 498, 0, - 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 520, 1096, 0, 0, 0, 0, - 0, 0, 1097, 1098, 1099, 0, 0, 0, 0, 1100, - 0, 1101, 0, 0, 0, 0, 0, 1102, 1103, 1104, - 1105, 117, 1056, 821, 1057, 1058, 1059, 1060, 1061, 0, + 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, + 126, 127, 128, 0, 0, 0, 0, 0, 1062, 0, + 0, 129, 130, 131, 0, 132, 133, 134, 135, 136, + 137, 138, 139, 1063, 141, 1064, 1065, 0, 144, 145, + 146, 147, 148, 149, 1066, 790, 150, 151, 152, 153, + 1067, 1068, 156, 0, 157, 158, 159, 160, 791, 0, + 792, 0, 1069, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, + 179, 180, 181, 3566, 183, 184, 185, 186, 187, 188, + 189, 1070, 191, 192, 1071, 194, 1072, 195, 0, 196, + 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, + 205, 0, 0, 206, 207, 1073, 209, 210, 0, 211, + 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, + 220, 1074, 222, 223, 224, 225, 226, 227, 793, 1075, + 229, 0, 230, 231, 1076, 233, 0, 234, 0, 235, + 236, 0, 237, 238, 239, 240, 241, 242, 0, 243, + 0, 1077, 1078, 246, 247, 0, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 0, 0, 289, 290, 291, 292, 0, 293, 294, + 295, 296, 297, 298, 299, 300, 1082, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 1083, 323, 1084, + 325, 326, 327, 328, 1085, 329, 330, 331, 332, 1086, + 795, 334, 1087, 336, 337, 338, 0, 339, 340, 0, + 0, 1088, 342, 343, 0, 0, 344, 345, 346, 347, + 348, 349, 797, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, + 798, 365, 366, 367, 368, 369, 370, 371, 0, 372, + 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, + 382, 1089, 384, 385, 386, 387, 0, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 0, 401, 402, 403, 404, 405, 406, 1090, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 0, 430, 431, 432, 1091, 434, 0, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, 447, 448, 800, 0, 0, 450, 451, 0, 452, + 453, 454, 455, 456, 457, 458, 0, 459, 1092, 1093, + 0, 0, 462, 463, 801, 465, 802, 1094, 467, 468, + 803, 470, 471, 3567, 473, 474, 0, 0, 475, 476, + 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, + 485, 486, 487, 1095, 489, 0, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, + 520, 1096, 0, 0, 0, 0, 0, 0, 1097, 1098, + 1099, 0, 0, 0, 0, 1100, 0, 1101, 0, 0, + 0, 0, 0, 1102, 1103, 1104, 1105, 117, 1056, 821, + 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, + 0, 0, 0, 1062, 0, 0, 129, 130, 131, 0, + 132, 133, 134, 135, 136, 137, 138, 139, 1063, 141, + 1064, 1065, 0, 144, 145, 146, 147, 148, 149, 1066, + 790, 150, 151, 152, 153, 1067, 1068, 156, 0, 157, + 158, 159, 160, 791, 0, 792, 0, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 1070, 191, 192, 1071, + 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, + 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, + 1073, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 1074, 222, 223, 224, + 225, 226, 227, 793, 1075, 229, 0, 230, 231, 1076, + 233, 0, 234, 0, 235, 236, 0, 237, 238, 239, + 240, 241, 242, 0, 243, 0, 1077, 1078, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, + 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 1079, 1080, 0, 1081, 0, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 290, + 291, 292, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 1082, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 1083, 323, 1084, 325, 326, 327, 328, 0, + 329, 330, 331, 332, 1086, 795, 334, 1087, 336, 337, + 338, 0, 339, 340, 0, 0, 1088, 342, 343, 0, + 0, 344, 345, 346, 347, 348, 349, 797, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, + 0, 0, 0, 362, 363, 798, 365, 366, 367, 368, + 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, + 0, 378, 379, 380, 381, 382, 1089, 384, 385, 386, + 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 0, 401, 402, 403, 404, + 405, 406, 1090, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 0, 430, 431, + 432, 1091, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 447, 448, 800, 0, + 0, 450, 451, 0, 452, 453, 454, 455, 456, 457, + 458, 0, 459, 1092, 1093, 0, 0, 462, 463, 801, + 465, 802, 1094, 467, 468, 803, 470, 471, 472, 473, + 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 487, 1095, 489, + 0, 490, 491, 492, 493, 494, 495, 496, 497, 498, + 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 520, 0, 0, 0, 0, + 0, 0, 0, 1435, 1436, 0, 0, 0, 0, 0, + 1100, 0, 1101, 0, 0, 0, 0, 0, 1102, 1103, + 1104, 1105, 117, 1056, 821, 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, - 127, 128, 0, 0, 0, 0, 0, 1062, 0, 0, - 129, 130, 131, 0, 132, 133, 134, 135, 136, 137, - 138, 139, 1063, 141, 1064, 1065, 0, 144, 145, 146, - 147, 148, 149, 1066, 790, 150, 151, 152, 153, 1067, - 1068, 156, 0, 157, 158, 159, 160, 791, 0, 792, - 0, 1069, 164, 165, 166, 167, 168, 169, 170, 171, - 172, 0, 173, 174, 175, 176, 177, 178, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 1070, 191, 192, 1071, 194, 1072, 195, 0, 196, 197, - 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, - 0, 0, 206, 207, 1073, 209, 210, 0, 211, 212, - 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, - 1074, 222, 223, 224, 225, 226, 227, 793, 1075, 229, - 0, 230, 231, 1076, 233, 0, 234, 0, 235, 236, - 0, 237, 238, 239, 240, 241, 242, 0, 243, 0, - 1077, 1078, 246, 247, 0, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, - 262, 263, 264, 265, 266, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, - 0, 0, 289, 290, 291, 292, 0, 293, 294, 295, - 296, 297, 298, 299, 300, 1082, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 1083, 323, 1084, 325, - 326, 327, 328, 1085, 329, 330, 331, 332, 1086, 795, - 334, 1087, 336, 337, 338, 0, 339, 340, 0, 0, - 1088, 342, 343, 0, 0, 344, 345, 346, 347, 348, - 349, 797, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, 361, 0, 0, 0, 0, 362, 363, 798, - 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, - 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, - 1089, 384, 385, 386, 387, 0, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, - 401, 402, 403, 404, 405, 406, 1090, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, - 429, 0, 430, 431, 432, 1091, 434, 0, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - 447, 448, 800, 0, 0, 450, 451, 0, 452, 453, - 454, 455, 456, 457, 458, 0, 459, 1092, 1093, 0, - 0, 462, 463, 801, 465, 802, 1094, 467, 468, 803, - 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, - 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, - 486, 487, 1095, 489, 0, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, - 1096, 0, 0, 0, 0, 0, 0, 1097, 2323, 1099, - 0, 0, 0, 0, 1100, 0, 1101, 0, 0, 0, - 0, 0, 1102, 1103, 1104, 1105, 117, 1056, 821, 1057, - 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 0, 0, 1062, 0, 0, 129, 130, 131, 0, 132, - 133, 134, 135, 136, 137, 138, 139, 1063, 141, 1064, - 1065, 0, 144, 145, 146, 147, 148, 149, 1066, 790, - 150, 151, 152, 153, 1067, 1068, 156, 0, 157, 158, - 159, 160, 791, 0, 792, 0, 1069, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 1070, 191, 192, 1071, 194, - 1072, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 1073, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 1074, 222, 223, 224, 225, - 226, 227, 793, 1075, 229, 0, 230, 231, 1076, 233, - 0, 234, 0, 235, 236, 0, 237, 238, 239, 240, - 241, 242, 0, 243, 0, 1077, 1078, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 1079, - 1080, 0, 1081, 0, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 290, 291, - 292, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 1082, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 1083, 323, 1084, 325, 326, 327, 328, 1085, 329, - 330, 331, 332, 1086, 795, 334, 1087, 336, 337, 338, - 0, 339, 340, 0, 0, 1088, 342, 343, 0, 0, - 344, 345, 346, 347, 348, 349, 797, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 798, 365, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 1089, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 403, 404, 405, - 406, 1090, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 430, 431, 432, - 1091, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 447, 448, 800, 0, 0, - 450, 451, 0, 452, 453, 454, 455, 456, 457, 458, - 0, 459, 1092, 1093, 0, 0, 462, 463, 801, 465, - 802, 1094, 467, 468, 803, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 1095, 489, 0, - 490, 491, 492, 493, 494, 495, 496, 497, 498, 0, - 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 520, 1096, 0, 0, 0, 0, - 0, 0, 1097, 1098, 1099, 0, 0, 0, 0, 1100, - 0, 2544, 0, 0, 0, 0, 0, 1102, 1103, 1104, - 1105, 117, 1056, 821, 1057, 1058, 1059, 1060, 1061, 0, + 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, + 126, 127, 128, 0, 0, 0, 0, 0, 1062, 0, + 0, 129, 130, 131, 0, 132, 133, 134, 135, 136, + 137, 138, -2102, 1063, 141, 1064, 1065, 0, 144, 145, + 146, 147, 148, 149, 1066, 790, 150, 151, 152, 153, + 1067, 1068, 156, 0, 157, 158, 159, 160, 791, 0, + 792, 0, 1069, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, + 179, 180, 181, 3566, 183, 184, 185, 186, 187, 188, + 189, 1070, 191, 192, 1071, 194, 1072, 195, 0, 196, + 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, + 205, 0, 0, 206, 207, 1073, 209, 210, 0, 211, + 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, + 220, 1074, 222, 223, 224, 225, 226, 227, 793, 1075, + 229, 0, 230, 231, 1076, 233, 0, 234, 0, 235, + 236, 0, 237, 238, 239, 240, -2102, 242, 0, 243, + 0, 1077, 1078, 246, 247, 0, 248, 249, 250, 251, + 252, 253, 254, -2102, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, + 278, 0, 0, 281, 282, 283, 284, 285, 286, 287, + 288, 0, 0, 289, 290, 291, -2102, 0, 293, 294, + 295, 296, 297, 298, 299, 300, 1082, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 1083, 323, 1084, + 325, 326, 327, 328, 0, 329, 330, 0, 332, 1086, + 795, 334, 1087, 336, 337, 338, 0, 339, 340, 0, + 0, 1088, 342, 343, 0, 0, 344, 345, 346, 347, + 348, 349, 797, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, + 798, 365, 366, 367, 368, 369, 370, 371, 0, 372, + 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, + 382, 1089, 384, 385, 386, 387, 0, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 0, 401, 402, 403, 404, 405, 406, 1090, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 0, -2102, 431, 432, 1091, 434, 0, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, 447, 448, 800, 0, 0, 450, 451, 0, 452, + 453, 454, 455, 456, 457, 458, 0, 459, 1092, 1093, + 0, 0, 462, 463, 801, 465, 802, 1094, 467, 468, + 803, 470, 471, 3567, 473, 474, 0, 0, 475, 476, + 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, + 485, 486, 487, 1095, 489, 0, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, + 520, -2102, 0, 0, 0, 0, 0, 0, 1097, 1098, + 1099, 0, 0, 0, 0, 1100, 0, 1101, 0, 0, + 0, 0, 0, 1102, 1103, 1104, 1105, 117, 1056, 821, + 1057, 1058, 0, 1060, 1061, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, + 0, 0, 0, 1062, 0, 0, 129, 130, 131, 0, + 132, 133, 134, 135, 136, 137, 138, 139, 1063, 141, + 1064, 1065, 0, 144, 145, 146, 147, 148, 149, 1066, + 790, 150, 151, 152, 153, 1067, 1068, 156, 0, 157, + 158, 159, 160, 791, 0, 792, 0, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 1070, 191, 192, 1071, + 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, + 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, + 1073, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 1074, 222, 223, 224, + 225, 226, 227, 793, 1075, 229, 0, 230, 231, 1076, + 233, 0, 234, 0, 235, 236, 0, 237, 238, 239, + 240, 241, 242, 0, 243, 0, 1077, 1078, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, + 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 1079, 1080, 0, 1081, 0, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 290, + 291, 292, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 1082, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 1083, 323, 1084, 325, 326, 327, 328, 0, + 329, 330, 331, 332, 1086, 795, 334, 1087, 336, 337, + 338, 0, 339, 340, 0, 0, 341, 342, 343, 0, + 0, 344, 345, 346, 347, 348, 349, 797, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, + 0, 0, 0, 362, 363, 798, 365, 366, 367, 368, + 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, + 0, 378, 379, 380, 381, 382, 1089, 384, 385, 386, + 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 0, 401, 402, 403, 404, + 405, 406, 2224, 2225, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 0, 430, 431, + 432, 1091, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 447, 448, 800, 0, + 0, 450, 451, 0, 452, 453, 454, 455, 456, 457, + 458, 0, 459, 1092, 1093, 0, 0, 462, 463, 801, + 465, 802, 1094, 467, 468, 803, 470, 471, 472, 473, + 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 487, 1095, 489, + 0, 490, 491, 492, 493, 494, 495, 496, 497, 498, + 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 520, 0, 0, 0, 0, + 0, 0, 0, 2226, 2227, 0, 0, 0, 0, 0, + 1100, 0, 1101, 0, 0, 0, 0, 0, 1102, 1103, + 1104, 1105, 117, 1056, 821, 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, - 127, 128, 0, 0, 0, 0, 0, 1062, 0, 0, - 129, 130, 131, 0, 132, 133, 134, 135, 136, 137, - 138, 139, 1063, 141, 1064, 1065, 0, 144, 145, 146, - 147, 148, 149, 1066, 790, 150, 151, 152, 153, 1067, - 1068, 156, 0, 157, 158, 159, 160, 791, 0, 792, - 0, 1069, 164, 165, 166, 167, 168, 169, 170, 171, - 172, 0, 173, 174, 175, 176, 177, 178, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 1070, 191, 192, 1071, 194, 1072, 195, 0, 196, 197, - 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, - 0, 0, 206, 207, 1073, 209, 210, 0, 211, 212, - 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, - 1074, 222, 223, 224, 225, 226, 227, 793, 1075, 229, - 0, 230, 231, 1076, 233, 0, 234, 0, 235, 236, - 0, 237, 238, 239, 240, 241, 242, 0, 243, 0, - 1077, 1078, 246, 247, 0, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, - 262, 263, 264, 265, 266, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, - 0, 0, 289, 290, 291, 292, 0, 293, 294, 295, - 296, 297, 298, 299, 300, 1082, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 1083, 323, 1084, 325, - 326, 327, 328, 1085, 329, 330, 331, 332, 1086, 795, - 334, 1087, 336, 337, 338, 0, 339, 340, 0, 0, - 1088, 342, 343, 0, 0, 344, 345, 346, 347, 348, - 349, 797, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, 361, 0, 0, 0, 0, 362, 363, 798, - 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, - 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, - 1089, 384, 385, 386, 387, 0, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, - 401, 402, 403, 404, 405, 406, 1090, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, - 429, 0, 430, 431, 432, 1091, 434, 0, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - 447, 448, 800, 0, 0, 450, 451, 0, 452, 453, - 454, 455, 456, 457, 458, 0, 459, 1092, 1093, 0, - 0, 462, 463, 801, 465, 802, 1094, 467, 468, 803, - 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, - 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, - 486, 487, 1095, 489, 0, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, - 1096, 0, 0, 0, 0, 0, 0, 1097, 3156, 1099, - 0, 0, 0, 0, 1100, 0, 1101, 0, 0, 0, - 0, 0, 1102, 1103, 1104, 1105, 117, 1056, 821, 1057, - 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 0, 0, 1062, 0, 0, 129, 130, 131, 0, 132, - 133, 134, 135, 136, 137, 138, 139, 1063, 141, 1064, - 1065, 0, 144, 145, 146, 147, 148, 149, 1066, 790, - 150, 151, 152, 153, 1067, 1068, 156, 0, 157, 158, - 159, 160, 791, 0, 792, 0, 1069, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 179, 180, 3096, 182, 183, 184, - 185, 186, 187, 188, 189, 1070, 191, 192, 1071, 194, - 1072, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 1073, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 1074, 222, 223, 224, 225, - 226, 227, 793, 1075, 229, 0, 230, 231, 1076, 233, - 0, 234, 0, 235, 236, 0, 237, 238, 239, 240, - 241, 242, 0, 243, 0, 3097, 1078, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 1079, - 1080, 0, 1081, 0, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 290, 291, - 292, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 1082, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 1083, 323, 1084, 325, 326, 327, 328, 1085, 329, - 330, 331, 332, 1086, 795, 334, 1087, 336, 337, 338, - 0, 339, 340, 0, 0, 1088, 342, 343, 0, 0, - 344, 345, 346, 347, 348, 349, 797, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 798, 365, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 1089, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 403, 404, 405, - 3098, 1090, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 430, 431, 432, - 1091, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 447, 448, 800, 0, 0, - 450, 451, 0, 452, 453, 454, 455, 456, 457, 458, - 0, 459, 1092, 1093, 0, 0, 462, 463, 801, 465, - 802, 1094, 467, 468, 803, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 1095, 489, 0, - 490, 491, 492, 493, 494, 495, 496, 497, 498, 0, - 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 520, 1096, 0, 0, 0, 0, - 0, 0, 1097, 1098, 1099, 0, 0, 0, 0, 1100, - 0, 3099, 0, 0, 0, 0, 0, 1102, 1103, 1104, - 1105, 117, 1056, 821, 1057, 1058, 1059, 1060, 1061, 0, + 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, + 126, 127, 128, 0, 0, 0, 0, 0, 1062, 0, + 0, 129, 130, 131, 0, 132, 133, 134, 135, 136, + 137, 138, 139, 1063, 141, 1064, 1065, 0, 144, 145, + 146, 147, 148, 149, 1066, 790, 150, 151, 152, 153, + 1067, 1068, 156, 0, 157, 158, 159, 160, 791, 0, + 792, 0, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 1070, 191, 192, 1071, 194, 0, 195, 0, 196, + 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, + 205, 0, 0, 206, 207, 1073, 209, 210, 0, 211, + 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, + 220, 1074, 222, 223, 224, 225, 226, 227, 793, 1075, + 229, 0, 230, 231, 1076, 233, 0, 234, 0, 235, + 236, 0, 237, 238, 239, 240, 241, 242, 0, 243, + 0, 1077, 1078, 246, 247, 0, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, + 278, 0, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 0, 0, 289, 290, 291, 292, 0, 293, 294, + 295, 296, 297, 298, 299, 300, 1082, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 1083, 323, 1084, + 325, 326, 327, 328, 0, 329, 330, 331, 332, 1086, + 795, 334, 1087, 336, 337, 338, 0, 339, 340, 0, + 0, 1088, 342, 343, 0, 0, 344, 345, 346, 347, + 348, 349, 797, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, + 798, 365, 366, 367, 368, 369, 370, 371, 0, 372, + 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, + 382, 1089, 384, 385, 386, 387, 0, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 0, 401, 402, 403, 404, 405, 406, 1090, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 0, 430, 431, 432, 1091, 434, 0, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, 447, 448, 800, 0, 0, 450, 451, 0, 452, + 453, 454, 455, 456, 457, 458, 0, 459, 1092, 1093, + 0, 0, 462, 463, 801, 465, 802, 1094, 467, 468, + 803, 470, 471, 472, 473, 474, 0, 0, 475, 476, + 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, + 485, 486, 487, 1095, 489, 0, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, + 520, 0, 0, 0, 0, 0, 0, 0, 1435, 1436, + 0, 0, 0, 0, 0, 1100, 0, 1101, 0, 0, + 0, 0, 0, 1102, 1103, 1104, 1105, 117, 1056, 821, + 1057, 1058, 0, 1060, 1061, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, + 0, 0, 0, 1062, 0, 0, 129, 130, 131, 0, + 132, 133, 134, 135, 136, 137, 138, 139, 1063, 141, + 1064, 1065, 0, 144, 145, 146, 147, 148, 149, 1066, + 790, 150, 151, 152, 153, 1067, 1068, 156, 0, 157, + 158, 159, 160, 791, 0, 792, 0, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 1070, 191, 192, 1071, + 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, + 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, + 1073, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 1074, 222, 223, 224, + 225, 226, 227, 793, 1075, 229, 0, 230, 231, 1076, + 233, 0, 234, 0, 235, 236, 0, 237, 238, 239, + 240, 241, 242, 0, 243, 3117, 1077, 1078, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, + 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 1079, 1080, 0, 1081, 0, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 290, + 291, 292, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 1082, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 1083, 323, 1084, 325, 326, 327, 328, 0, + 329, 330, 331, 332, 1086, 795, 334, 1087, 336, 337, + 338, 0, 339, 340, 0, 0, 341, 342, 343, 0, + 0, 344, 345, 346, 347, 348, 349, 797, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, + 0, 0, 0, 362, 363, 798, 365, 366, 367, 368, + 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, + 0, 378, 379, 380, 381, 382, 1089, 384, 385, 386, + 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 0, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 0, 430, 431, + 432, 1091, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 447, 448, 800, 0, + 0, 450, 451, 0, 452, 453, 454, 455, 456, 457, + 458, 0, 459, 1092, 1093, 0, 0, 462, 463, 801, + 465, 802, 1094, 467, 468, 803, 470, 471, 472, 473, + 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 487, 1095, 489, + 0, 490, 491, 492, 493, 494, 495, 496, 497, 498, + 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 520, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1100, 0, 2800, 0, 0, 0, 0, 0, 1102, 1103, + 1104, 1105, 117, 1056, 821, 1057, 1058, 0, 1060, 1061, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, + 126, 127, 128, 0, 0, 0, 0, 0, 1062, 0, + 0, 129, 130, 131, 0, 132, 133, 134, 135, 136, + 137, 138, 139, 1063, 141, 1064, 1065, 0, 144, 145, + 146, 147, 148, 149, 1066, 790, 150, 151, 152, 153, + 1067, 1068, 156, 0, 157, 158, 159, 160, 791, 0, + 792, 0, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 1070, 191, 192, 1071, 194, 0, 195, 0, 196, + 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, + 205, 0, 0, 206, 207, 1073, 209, 210, 0, 211, + 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, + 220, 1074, 222, 223, 224, 225, 226, 227, 793, 1075, + 229, 0, 230, 231, 1076, 233, 0, 234, 0, 235, + 236, 0, 237, 238, 239, 240, 241, 242, 0, 243, + 0, 1077, 1078, 246, 247, 0, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 0, 0, 289, 290, 291, 292, 0, 293, 294, + 295, 296, 297, 298, 299, 300, 1082, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 1083, 323, 1084, + 325, 326, 327, 328, 0, 329, 330, 331, 332, 1086, + 795, 334, 1087, 336, 337, 338, 0, 339, 340, 0, + 0, 341, 342, 343, 0, 0, 344, 345, 346, 347, + 348, 349, 797, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, + 798, 365, 366, 367, 368, 369, 370, 371, 0, 372, + 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, + 382, 1089, 384, 385, 386, 387, 0, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 0, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 0, 430, 431, 432, 1091, 434, 0, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, 447, 448, 800, 0, 0, 450, 451, 0, 452, + 453, 454, 455, 456, 457, 458, 0, 459, 1092, 1093, + 0, 0, 462, 463, 801, 465, 802, 1094, 467, 468, + 803, 470, 471, 472, 473, 474, 0, 0, 475, 476, + 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, + 485, 486, 487, 1095, 489, 0, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, + 520, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1100, 0, 2800, 0, 0, + 0, 0, 0, 1102, 1103, 1104, 1105, 117, 1056, 821, + 1057, 1058, 0, 1060, 1061, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, + 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, + 0, 0, 0, 1062, 0, 0, 129, 130, 131, 0, + 132, 133, 134, 135, 136, 137, 138, 139, 1063, 141, + 1064, 1065, 0, 144, 145, 146, 147, 148, 149, 1066, + 790, 150, 151, 152, 153, 1067, 1068, 156, 0, 157, + 158, 159, 160, 791, 0, 792, 0, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 179, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 1070, 191, 192, 1071, + 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, + 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, + 1073, 209, 210, 0, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 1074, 222, 223, 224, + 225, 226, 227, 793, 1075, 229, 0, 230, 231, 1076, + 233, 0, 234, 0, 235, 236, 0, 237, 238, 239, + 240, 241, 242, 0, 243, 0, 1077, 1078, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, + 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 1079, 1080, 0, 1081, 0, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 290, + 291, 292, 0, 293, 294, 295, 296, 297, 298, 299, + 300, 1082, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 1083, 323, 1084, 325, 326, 327, 328, 0, + 329, 330, 331, 332, 1086, 795, 334, 1087, 336, 337, + 338, 0, 339, 340, 0, 0, 341, 342, 343, 0, + 0, 344, 345, 346, 347, 348, 349, 797, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, + 0, 0, 0, 362, 363, 798, 365, 366, 367, 368, + 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, + 0, 378, 379, 380, 381, 382, 1089, 384, 385, 386, + 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, 399, 400, 0, 401, 402, 403, 404, + 405, 406, 1090, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 0, 430, 431, + 432, 1091, 434, 0, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 447, 448, 800, 0, + 0, 450, 451, 0, 452, 453, 454, 455, 456, 457, + 458, 0, 459, 1092, 1093, 0, 0, 462, 463, 801, + 465, 802, 1094, 467, 468, 803, 470, 471, 472, 473, + 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, + 481, 0, 482, 483, 484, 485, 486, 487, 1095, 489, + 0, 490, 491, 492, 493, 494, 495, 496, 497, 498, + 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 520, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1100, 0, 1101, 0, 0, 0, 0, 0, 1102, 1103, + 1104, 1105, 117, 1056, 821, 1057, 1058, 1059, 1060, 1061, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, + 126, 127, 128, 0, 0, 0, 0, 0, 1062, 0, + 0, 129, 130, 131, 0, 132, 133, 134, 135, 136, + 137, 138, 0, 1063, 141, 1064, 1065, 0, 144, 145, + 146, 147, 148, 149, 1066, 790, 150, 151, 152, 153, + 1067, 1068, 156, 0, 157, 158, 159, 160, 791, 0, + 792, 0, 1069, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 1070, 191, 192, 1071, 194, 1072, 195, 0, 196, + 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, + 205, 0, 0, 206, 207, 1073, 209, 210, 0, 211, + 212, 213, 0, 214, 0, 216, 0, 217, 218, 219, + 220, 1074, 222, 223, 224, 225, 226, 227, 793, 1075, + 229, 0, 230, 231, 1076, 233, 0, 234, 0, 235, + 236, 0, 237, 238, 239, 240, 0, 242, 0, 243, + 0, 1077, 1078, 246, 247, 0, 248, 249, 250, 251, + 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, + 270, 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, + 278, 0, 0, 281, 282, 283, 284, 285, 286, 287, + 288, 0, 0, 289, 290, 291, 0, 0, 293, 294, + 295, 296, 297, 298, 299, 300, 1082, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 1083, 323, 1084, + 325, 326, 327, 328, 0, 329, 330, 0, 332, 1086, + 795, 334, 1087, 336, 337, 338, 0, 339, 340, 0, + 0, 1088, 342, 343, 0, 0, 344, 345, 346, 347, + 348, 349, 797, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, + 798, 365, 366, 367, 368, 369, 370, 371, 0, 372, + 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, + 382, 1089, 384, 385, 386, 387, 0, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 0, 401, 402, 403, 404, 405, 406, 1090, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 0, 0, 431, 432, 1091, 434, 0, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, 447, 448, 800, 0, 0, 450, 451, 0, 452, + 453, 454, 455, 456, 457, 458, 0, 459, 1092, 1093, + 0, 0, 462, 463, 801, 465, 802, 1094, 467, 468, + 803, 470, 471, 472, 473, 474, 0, 0, 475, 476, + 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, + 485, 486, 487, 1095, 489, 0, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, + 520, 0, 0, 0, 0, 0, 0, 0, 1097, 1098, + 1099, 0, 974, 1364, 821, 1100, 0, 1101, 1060, 0, + 0, 0, 0, 1102, 1103, 1104, 1105, 0, 0, 0, + 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, + 126, 127, 128, 0, 0, 0, 565, 0, 0, 0, + 0, 570, 130, 131, 0, 132, 133, 134, 572, 136, + 137, 138, 573, 574, 575, 576, 577, 0, 144, 145, + 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, + 581, 582, 156, 0, 157, 158, 159, 160, 584, 0, + 586, 0, 588, 164, 165, 166, 167, 168, 589, 170, + 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, + 592, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 594, 191, 192, 595, 194, 0, 195, 0, 196, + 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, + 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, + 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, + 220, 605, 222, 223, 224, 225, 226, 227, 606, 1365, + 229, 0, 230, 231, 609, 233, 0, 234, 0, 235, + 612, 0, 614, 238, 239, 615, 616, 242, 0, 243, + 0, 619, 620, 246, 247, 0, 248, 249, 250, 251, + 252, 253, 254, 622, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 625, 626, + 270, 271, 272, 273, 274, 627, 628, 0, 630, 0, + 278, 632, 633, 281, 634, 283, 284, 285, 286, 287, + 288, 0, 0, 289, 637, 291, 638, 0, 293, 294, + 295, 296, 297, 298, 299, 300, 2406, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 641, 642, 643, + 325, 326, 327, 644, 0, 329, 330, 646, 332, 0, + 648, 334, 649, 336, 337, 338, 0, 339, 340, 1366, + 0, 341, 342, 343, 0, 0, 344, 345, 655, 656, + 348, 657, 658, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, + 663, 664, 366, 367, 665, 369, 370, 371, 0, 372, + 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, + 382, 668, 384, 385, 386, 387, 0, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 0, 401, 402, 671, 404, 405, 406, 672, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 0, 674, 421, 422, 423, 424, 425, 426, 675, + 428, 429, 0, 677, 431, 432, 678, 434, 0, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, 680, 448, 681, 0, 0, 450, 451, 0, 452, + 685, 454, 455, 456, 457, 458, 0, 459, 687, 688, + 0, 0, 462, 463, 691, 465, 692, 1367, 467, 468, + 694, 470, 471, 472, 473, 474, 0, 0, 475, 476, + 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, + 485, 486, 699, 700, 489, 0, 490, 702, 492, 493, + 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, + 500, 501, 502, 503, 504, 505, 707, 708, 709, 710, + 711, 712, 713, 714, 715, 716, 717, 517, 518, 519, + 520, 0, 0, 0, 0, 0, 0, 0, 1368, 1369, + 2407, 117, 0, 0, 0, 2408, 0, 2409, 1061, 0, + 0, 0, 0, 0, 0, 0, 1105, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, 1062, 0, 0, 129, 130, 131, 0, 132, 133, 134, 135, 136, 137, - 138, 3564, 1063, 141, 1064, 1065, 0, 144, 145, 146, - 147, 148, 149, 1066, 790, 150, 151, 152, 153, 1067, - 1068, 156, 0, 157, 158, 159, 160, 791, 0, 792, - 0, 1069, 164, 165, 166, 167, 168, 169, 170, 171, + 138, 139, 140, 141, 142, 143, 0, 144, 145, 146, + 147, 148, 149, 1066, 790, 150, 151, 152, 153, 154, + 155, 156, 0, 157, 158, 159, 160, 791, 0, 792, + 0, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, 179, - 180, 181, 3565, 183, 184, 185, 186, 187, 188, 189, - 1070, 191, 192, 1071, 194, 1072, 195, 0, 196, 197, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, - 0, 0, 206, 207, 1073, 209, 210, 0, 211, 212, + 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, - 1074, 222, 223, 224, 225, 226, 227, 793, 1075, 229, - 0, 230, 231, 1076, 233, 0, 234, 0, 235, 236, + 221, 222, 223, 224, 225, 226, 227, 793, 0, 229, + 0, 230, 231, 232, 233, 0, 234, 0, 235, 236, 0, 237, 238, 239, 240, 241, 242, 0, 243, 0, - 1077, 1078, 246, 247, 0, 248, 249, 250, 251, 252, + 244, 245, 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, 278, + 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 0, 0, 289, 290, 291, 292, 0, 293, 294, 295, 296, 297, 298, 299, 300, 1082, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 1083, 323, 1084, 325, - 326, 327, 328, 1085, 329, 330, 331, 332, 1086, 795, - 334, 1087, 336, 337, 338, 0, 339, 340, 0, 0, - 1088, 342, 343, 0, 0, 344, 345, 346, 347, 348, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, 0, 329, 330, 331, 332, 0, 795, + 334, 335, 336, 337, 338, 0, 339, 340, 0, 0, + 341, 342, 343, 0, 0, 344, 345, 346, 347, 348, 349, 797, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, 798, 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, - 1089, 384, 385, 386, 387, 0, 388, 389, 390, 391, + 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, - 401, 402, 403, 404, 405, 406, 1090, 408, 409, 410, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, - 429, 0, 430, 431, 432, 1091, 434, 0, 435, 436, + 429, 0, 430, 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 800, 0, 0, 450, 451, 0, 452, 453, - 454, 455, 456, 457, 458, 0, 459, 1092, 1093, 0, - 0, 462, 463, 801, 465, 802, 1094, 467, 468, 803, - 470, 471, 3566, 473, 474, 0, 0, 475, 476, 477, + 454, 455, 456, 457, 458, 0, 459, 460, 461, 0, + 0, 462, 463, 801, 465, 802, 0, 467, 468, 803, + 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, - 486, 487, 1095, 489, 0, 490, 491, 492, 493, 494, + 486, 487, 488, 489, 0, 490, 491, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, - 1096, 0, 0, 0, 0, 0, 0, 1097, 1098, 1099, - 0, 0, 0, 0, 1100, 0, 1101, 0, 0, 0, - 0, 0, 1102, 1103, 1104, 1105, 117, 1056, 821, 1057, - 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 0, 0, 1062, 0, 0, 129, 130, 131, 0, 132, - 133, 134, 135, 136, 137, 138, 139, 1063, 141, 1064, - 1065, 0, 144, 145, 146, 147, 148, 149, 1066, 790, - 150, 151, 152, 153, 1067, 1068, 156, 0, 157, 158, - 159, 160, 791, 0, 792, 0, 1069, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 179, 180, 181, 3565, 183, 184, - 185, 186, 187, 188, 189, 1070, 191, 192, 1071, 194, - 1072, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 1073, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 1074, 222, 223, 224, 225, - 226, 227, 793, 1075, 229, 0, 230, 231, 1076, 233, - 0, 234, 0, 235, 236, 0, 237, 238, 239, 240, - 241, 242, 0, 243, 0, 1077, 1078, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 1079, - 1080, 0, 1081, 0, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 290, 291, - 292, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 1082, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 1083, 323, 1084, 325, 326, 327, 328, 1085, 329, - 330, 331, 332, 1086, 795, 334, 1087, 336, 337, 338, - 0, 339, 340, 0, 0, 1088, 342, 343, 0, 0, - 344, 345, 346, 347, 348, 349, 797, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 798, 365, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 1089, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 403, 404, 405, - 406, 1090, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 430, 431, 432, - 1091, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 447, 448, 800, 0, 0, - 450, 451, 0, 452, 453, 454, 455, 456, 457, 458, - 0, 459, 1092, 1093, 0, 0, 462, 463, 801, 465, - 802, 1094, 467, 468, 803, 470, 471, 3566, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 1095, 489, 0, - 490, 491, 492, 493, 494, 495, 496, 497, 498, 0, - 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 520, 1096, 0, 0, 0, 0, - 0, 0, 1097, 1098, 1099, 0, 0, 0, 0, 1100, - 0, 1101, 0, 0, 0, 0, 0, 1102, 1103, 1104, - 1105, 117, 1056, 821, 1057, 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 528, 1982, 0, 1100, 0, 2142, 1983, 1061, 0, + 0, 0, 1102, 1103, 1104, 1105, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, - 127, 128, 0, 0, 0, 0, 0, 1062, 0, 0, - 129, 130, 131, 0, 132, 133, 134, 135, 136, 137, - 138, 139, 1063, 141, 1064, 1065, 0, 144, 145, 146, - 147, 148, 149, 1066, 790, 150, 151, 152, 153, 1067, - 1068, 156, 0, 157, 158, 159, 160, 791, 0, 792, - 0, 163, 164, 165, 166, 167, 168, 169, 170, 171, - 172, 0, 173, 174, 175, 176, 177, 178, 0, 179, + 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, + 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, + 147, 148, 149, 0, 0, 150, 151, 152, 153, 154, + 155, 156, 0, 157, 158, 159, 160, 161, 0, 0, + 0, 163, 164, 165, 166, 167, 168, 0, 170, 171, + 172, 0, 173, 174, 175, 176, 177, 178, 0, 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 1070, 191, 192, 1071, 194, 0, 195, 0, 196, 197, + 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, - 0, 0, 206, 207, 1073, 209, 210, 0, 211, 212, + 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, - 1074, 222, 223, 224, 225, 226, 227, 793, 1075, 229, - 0, 230, 231, 1076, 233, 0, 234, 0, 235, 236, - 0, 237, 238, 239, 240, 241, 242, 0, 243, 0, - 1077, 1078, 246, 247, 0, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, - 262, 263, 264, 265, 266, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, - 0, 0, 289, 290, 291, 292, 0, 293, 294, 295, - 296, 297, 298, 299, 300, 1082, 302, 303, 304, 305, + 221, 222, 223, 224, 225, 226, 227, 228, 0, 229, + 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, + 0, 0, 238, 239, 529, 0, 242, 0, 243, 0, + 244, 245, 246, 247, 0, 248, 249, 250, 251, 252, + 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, + 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, + 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, + 0, 0, 281, 0, 283, 284, 285, 286, 287, 288, + 0, 0, 289, 0, 291, 0, 0, 293, 294, 295, + 296, 297, 298, 299, 300, 530, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 1083, 323, 1084, 325, - 326, 327, 328, 0, 329, 330, 331, 332, 1086, 795, - 334, 1087, 336, 337, 338, 0, 339, 340, 0, 0, - 1088, 342, 343, 0, 0, 344, 345, 346, 347, 348, - 349, 797, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, 361, 0, 0, 0, 0, 362, 363, 798, - 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, - 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, - 1089, 384, 385, 386, 387, 0, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, - 401, 402, 403, 404, 405, 406, 1090, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, - 429, 0, 430, 431, 432, 1091, 434, 0, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - 447, 448, 800, 0, 0, 450, 451, 0, 452, 453, - 454, 455, 456, 457, 458, 0, 459, 1092, 1093, 0, - 0, 462, 463, 801, 465, 802, 1094, 467, 468, 803, - 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, - 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, - 486, 487, 1095, 489, 0, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, - 0, 0, 0, 0, 0, 0, 0, 1435, 1436, 0, - 0, 0, 0, 0, 1100, 0, 1101, 0, 0, 0, - 0, 0, 1102, 1103, 1104, 1105, 117, 1056, 821, 1057, - 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 0, 0, 1062, 0, 0, 129, 130, 131, 0, 132, - 133, 134, 135, 136, 137, 138, -2102, 1063, 141, 1064, - 1065, 0, 144, 145, 146, 147, 148, 149, 1066, 790, - 150, 151, 152, 153, 1067, 1068, 156, 0, 157, 158, - 159, 160, 791, 0, 792, 0, 1069, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 179, 180, 181, 3565, 183, 184, - 185, 186, 187, 188, 189, 1070, 191, 192, 1071, 194, - 1072, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 1073, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 1074, 222, 223, 224, 225, - 226, 227, 793, 1075, 229, 0, 230, 231, 1076, 233, - 0, 234, 0, 235, 236, 0, 237, 238, 239, 240, - -2102, 242, 0, 243, 0, 1077, 1078, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, -2102, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 1079, - 1080, 0, 1081, 0, 278, 0, 0, 281, 282, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 290, 291, - -2102, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 1082, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 1083, 323, 1084, 325, 326, 327, 328, 0, 329, - 330, 0, 332, 1086, 795, 334, 1087, 336, 337, 338, - 0, 339, 340, 0, 0, 1088, 342, 343, 0, 0, - 344, 345, 346, 347, 348, 349, 797, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 798, 365, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 1089, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 403, 404, 405, - 406, 1090, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, -2102, 431, 432, - 1091, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 447, 448, 800, 0, 0, - 450, 451, 0, 452, 453, 454, 455, 456, 457, 458, - 0, 459, 1092, 1093, 0, 0, 462, 463, 801, 465, - 802, 1094, 467, 468, 803, 470, 471, 3566, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 1095, 489, 0, - 490, 491, 492, 493, 494, 495, 496, 497, 498, 0, - 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 520, -2102, 0, 0, 0, 0, - 0, 0, 1097, 1098, 1099, 0, 0, 0, 0, 1100, - 0, 1101, 0, 0, 0, 0, 0, 1102, 1103, 1104, - 1105, 117, 1056, 821, 1057, 1058, 0, 1060, 1061, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, - 127, 128, 0, 0, 0, 0, 0, 1062, 0, 0, - 129, 130, 131, 0, 132, 133, 134, 135, 136, 137, - 138, 139, 1063, 141, 1064, 1065, 0, 144, 145, 146, - 147, 148, 149, 1066, 790, 150, 151, 152, 153, 1067, - 1068, 156, 0, 157, 158, 159, 160, 791, 0, 792, - 0, 163, 164, 165, 166, 167, 168, 169, 170, 171, - 172, 0, 173, 174, 175, 176, 177, 178, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 1070, 191, 192, 1071, 194, 0, 195, 0, 196, 197, - 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, - 0, 0, 206, 207, 1073, 209, 210, 0, 211, 212, - 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, - 1074, 222, 223, 224, 225, 226, 227, 793, 1075, 229, - 0, 230, 231, 1076, 233, 0, 234, 0, 235, 236, - 0, 237, 238, 239, 240, 241, 242, 0, 243, 0, - 1077, 1078, 246, 247, 0, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, - 262, 263, 264, 265, 266, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, - 0, 0, 289, 290, 291, 292, 0, 293, 294, 295, - 296, 297, 298, 299, 300, 1082, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 1083, 323, 1084, 325, - 326, 327, 328, 0, 329, 330, 331, 332, 1086, 795, - 334, 1087, 336, 337, 338, 0, 339, 340, 0, 0, - 341, 342, 343, 0, 0, 344, 345, 346, 347, 348, - 349, 797, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, 361, 0, 0, 0, 0, 362, 363, 798, - 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, - 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, - 1089, 384, 385, 386, 387, 0, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, - 401, 402, 403, 404, 405, 406, 2222, 2223, 409, 410, - 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, - 429, 0, 430, 431, 432, 1091, 434, 0, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - 447, 448, 800, 0, 0, 450, 451, 0, 452, 453, - 454, 455, 456, 457, 458, 0, 459, 1092, 1093, 0, - 0, 462, 463, 801, 465, 802, 1094, 467, 468, 803, - 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, - 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, - 486, 487, 1095, 489, 0, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, - 0, 0, 0, 0, 0, 0, 0, 2224, 2225, 0, - 0, 0, 0, 0, 1100, 0, 1101, 0, 0, 0, - 0, 0, 1102, 1103, 1104, 1105, 117, 1056, 821, 1057, - 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 0, 0, 1062, 0, 0, 129, 130, 131, 0, 132, - 133, 134, 135, 136, 137, 138, 139, 1063, 141, 1064, - 1065, 0, 144, 145, 146, 147, 148, 149, 1066, 790, - 150, 151, 152, 153, 1067, 1068, 156, 0, 157, 158, - 159, 160, 791, 0, 792, 0, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 1070, 191, 192, 1071, 194, - 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 1073, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 1074, 222, 223, 224, 225, - 226, 227, 793, 1075, 229, 0, 230, 231, 1076, 233, - 0, 234, 0, 235, 236, 0, 237, 238, 239, 240, - 241, 242, 0, 243, 0, 1077, 1078, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 1079, - 1080, 0, 1081, 0, 278, 0, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 290, 291, - 292, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 1082, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 1083, 323, 1084, 325, 326, 327, 328, 0, 329, - 330, 331, 332, 1086, 795, 334, 1087, 336, 337, 338, - 0, 339, 340, 0, 0, 1088, 342, 343, 0, 0, - 344, 345, 346, 347, 348, 349, 797, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 798, 365, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 1089, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 403, 404, 405, - 406, 1090, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 430, 431, 432, - 1091, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 447, 448, 800, 0, 0, - 450, 451, 0, 452, 453, 454, 455, 456, 457, 458, - 0, 459, 1092, 1093, 0, 0, 462, 463, 801, 465, - 802, 1094, 467, 468, 803, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 1095, 489, 0, - 490, 491, 492, 493, 494, 495, 496, 497, 498, 0, - 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 520, 0, 0, 0, 0, 0, - 0, 0, 1435, 1436, 0, 0, 0, 0, 0, 1100, - 0, 1101, 0, 0, 0, 0, 0, 1102, 1103, 1104, - 1105, 117, 1056, 821, 1057, 1058, 0, 1060, 1061, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, - 127, 128, 0, 0, 0, 0, 0, 1062, 0, 0, - 129, 130, 131, 0, 132, 133, 134, 135, 136, 137, - 138, 139, 1063, 141, 1064, 1065, 0, 144, 145, 146, - 147, 148, 149, 1066, 790, 150, 151, 152, 153, 1067, - 1068, 156, 0, 157, 158, 159, 160, 791, 0, 792, - 0, 163, 164, 165, 166, 167, 168, 169, 170, 171, - 172, 0, 173, 174, 175, 176, 177, 178, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 1070, 191, 192, 1071, 194, 0, 195, 0, 196, 197, - 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, - 0, 0, 206, 207, 1073, 209, 210, 0, 211, 212, - 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, - 1074, 222, 223, 224, 225, 226, 227, 793, 1075, 229, - 0, 230, 231, 1076, 233, 0, 234, 0, 235, 236, - 0, 237, 238, 239, 240, 241, 242, 0, 243, 3116, - 1077, 1078, 246, 247, 0, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, - 262, 263, 264, 265, 266, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, - 0, 0, 289, 290, 291, 292, 0, 293, 294, 295, - 296, 297, 298, 299, 300, 1082, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 1083, 323, 1084, 325, - 326, 327, 328, 0, 329, 330, 331, 332, 1086, 795, - 334, 1087, 336, 337, 338, 0, 339, 340, 0, 0, - 341, 342, 343, 0, 0, 344, 345, 346, 347, 348, - 349, 797, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, 361, 0, 0, 0, 0, 362, 363, 798, - 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, - 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, - 1089, 384, 385, 386, 387, 0, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, - 429, 0, 430, 431, 432, 1091, 434, 0, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - 447, 448, 800, 0, 0, 450, 451, 0, 452, 453, - 454, 455, 456, 457, 458, 0, 459, 1092, 1093, 0, - 0, 462, 463, 801, 465, 802, 1094, 467, 468, 803, - 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, - 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, - 486, 487, 1095, 489, 0, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1100, 0, 2799, 0, 0, 0, - 0, 0, 1102, 1103, 1104, 1105, 117, 1056, 821, 1057, - 1058, 0, 1060, 1061, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 0, 0, 1062, 0, 0, 129, 130, 131, 0, 132, - 133, 134, 135, 136, 137, 138, 139, 1063, 141, 1064, - 1065, 0, 144, 145, 146, 147, 148, 149, 1066, 790, - 150, 151, 152, 153, 1067, 1068, 156, 0, 157, 158, - 159, 160, 791, 0, 792, 0, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 1070, 191, 192, 1071, 194, - 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 1073, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 1074, 222, 223, 224, 225, - 226, 227, 793, 1075, 229, 0, 230, 231, 1076, 233, - 0, 234, 0, 235, 236, 0, 237, 238, 239, 240, - 241, 242, 0, 243, 0, 1077, 1078, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 1079, - 1080, 0, 1081, 0, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 290, 291, - 292, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 1082, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 1083, 323, 1084, 325, 326, 327, 328, 0, 329, - 330, 331, 332, 1086, 795, 334, 1087, 336, 337, 338, - 0, 339, 340, 0, 0, 341, 342, 343, 0, 0, - 344, 345, 346, 347, 348, 349, 797, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 798, 365, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 1089, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 430, 431, 432, - 1091, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 447, 448, 800, 0, 0, - 450, 451, 0, 452, 453, 454, 455, 456, 457, 458, - 0, 459, 1092, 1093, 0, 0, 462, 463, 801, 465, - 802, 1094, 467, 468, 803, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 1095, 489, 0, - 490, 491, 492, 493, 494, 495, 496, 497, 498, 0, - 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 520, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1100, - 0, 2799, 0, 0, 0, 0, 0, 1102, 1103, 1104, - 1105, 117, 1056, 821, 1057, 1058, 0, 1060, 1061, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, - 127, 128, 0, 0, 0, 0, 0, 1062, 0, 0, - 129, 130, 131, 0, 132, 133, 134, 135, 136, 137, - 138, 139, 1063, 141, 1064, 1065, 0, 144, 145, 146, - 147, 148, 149, 1066, 790, 150, 151, 152, 153, 1067, - 1068, 156, 0, 157, 158, 159, 160, 791, 0, 792, - 0, 163, 164, 165, 166, 167, 168, 169, 170, 171, - 172, 0, 173, 174, 175, 176, 177, 178, 0, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 1070, 191, 192, 1071, 194, 0, 195, 0, 196, 197, - 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, - 0, 0, 206, 207, 1073, 209, 210, 0, 211, 212, - 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, - 1074, 222, 223, 224, 225, 226, 227, 793, 1075, 229, - 0, 230, 231, 1076, 233, 0, 234, 0, 235, 236, - 0, 237, 238, 239, 240, 241, 242, 0, 243, 0, - 1077, 1078, 246, 247, 0, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, - 262, 263, 264, 265, 266, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 1079, 1080, 0, 1081, 0, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, - 0, 0, 289, 290, 291, 292, 0, 293, 294, 295, - 296, 297, 298, 299, 300, 1082, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 1083, 323, 1084, 325, - 326, 327, 328, 0, 329, 330, 331, 332, 1086, 795, - 334, 1087, 336, 337, 338, 0, 339, 340, 0, 0, - 341, 342, 343, 0, 0, 344, 345, 346, 347, 348, - 349, 797, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, 361, 0, 0, 0, 0, 362, 363, 798, - 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, + 316, 317, 318, 319, 320, 321, 322, 0, 324, 325, + 326, 327, 328, 0, 329, 330, 0, 332, 0, 333, + 334, 335, 336, 337, 338, 0, 339, 340, 0, 0, + 341, 342, 343, 0, 0, 344, 345, 346, 0, 348, + 0, 350, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 360, 361, 0, 0, 0, 0, 362, 363, 364, + 0, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, - 1089, 384, 385, 386, 387, 0, 388, 389, 390, 391, + 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, - 401, 402, 403, 404, 405, 406, 1090, 408, 409, 410, + 401, 402, 0, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, - 429, 0, 430, 431, 432, 1091, 434, 0, 435, 436, + 429, 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - 447, 448, 800, 0, 0, 450, 451, 0, 452, 453, - 454, 455, 456, 457, 458, 0, 459, 1092, 1093, 0, - 0, 462, 463, 801, 465, 802, 1094, 467, 468, 803, + 531, 448, 449, 0, 0, 450, 451, 0, 452, 0, + 454, 455, 456, 457, 458, 0, 459, 460, 461, 0, + 0, 462, 463, 464, 465, 466, 0, 467, 468, 469, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, - 486, 487, 1095, 489, 0, 490, 491, 492, 493, 494, + 486, 487, 488, 489, 0, 490, 0, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, + 0, 0, 0, 0, 0, 528, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1100, 0, 1101, 0, 0, 0, - 0, 0, 1102, 1103, 1104, 1105, 117, 1056, 821, 1057, - 1058, 1059, 1060, 1061, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 0, 0, 1062, 0, 0, 129, 130, 131, 0, 132, - 133, 134, 135, 136, 137, 138, 0, 1063, 141, 1064, - 1065, 0, 144, 145, 146, 147, 148, 149, 1066, 790, - 150, 151, 152, 153, 1067, 1068, 156, 0, 157, 158, - 159, 160, 791, 0, 792, 0, 1069, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 1070, 191, 192, 1071, 194, - 1072, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 1073, - 209, 210, 0, 211, 212, 213, 0, 214, 0, 216, - 0, 217, 218, 219, 220, 1074, 222, 223, 224, 225, - 226, 227, 793, 1075, 229, 0, 230, 231, 1076, 233, - 0, 234, 0, 235, 236, 0, 237, 238, 239, 240, - 0, 242, 0, 243, 0, 1077, 1078, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 0, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 1079, - 1080, 0, 1081, 0, 278, 0, 0, 281, 282, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 290, 291, - 0, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 1082, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 1083, 323, 1084, 325, 326, 327, 328, 0, 329, - 330, 0, 332, 1086, 795, 334, 1087, 336, 337, 338, - 0, 339, 340, 0, 0, 1088, 342, 343, 0, 0, - 344, 345, 346, 347, 348, 349, 797, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 798, 365, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 1089, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 403, 404, 405, - 406, 1090, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 0, 431, 432, - 1091, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 447, 448, 800, 0, 0, - 450, 451, 0, 452, 453, 454, 455, 456, 457, 458, - 0, 459, 1092, 1093, 0, 0, 462, 463, 801, 465, - 802, 1094, 467, 468, 803, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 1095, 489, 0, - 490, 491, 492, 493, 494, 495, 496, 497, 498, 0, - 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 520, 0, 0, 0, 0, 0, - 0, 0, 1097, 1098, 1099, 0, 974, 1364, 821, 1100, - 0, 1101, 1060, 0, 0, 0, 0, 1102, 1103, 1104, - 1105, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 565, 0, 0, 0, 0, 570, 130, 131, 0, 132, - 133, 134, 572, 136, 137, 138, 573, 574, 575, 576, - 577, 0, 144, 145, 146, 147, 148, 149, 0, 0, - 150, 151, 152, 153, 581, 582, 156, 0, 157, 158, - 159, 160, 584, 0, 586, 0, 588, 164, 165, 166, - 167, 168, 589, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 592, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 594, 191, 192, 595, 194, - 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 605, 222, 223, 224, 225, - 226, 227, 606, 1365, 229, 0, 230, 231, 609, 233, - 0, 234, 0, 235, 612, 0, 614, 238, 239, 615, - 616, 242, 0, 243, 0, 619, 620, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 622, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 625, 626, 270, 271, 272, 273, 274, 627, - 628, 0, 630, 0, 278, 632, 633, 281, 634, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 637, 291, - 638, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 2403, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 641, 642, 643, 325, 326, 327, 644, 0, 329, - 330, 646, 332, 0, 648, 334, 649, 336, 337, 338, - 0, 339, 340, 1366, 0, 341, 342, 343, 0, 0, - 344, 345, 655, 656, 348, 657, 658, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 663, 664, 366, 367, 665, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 668, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 671, 404, 405, - 406, 672, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 674, 421, 422, 423, - 424, 425, 426, 675, 428, 429, 0, 677, 431, 432, - 678, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 680, 448, 681, 0, 0, - 450, 451, 0, 452, 685, 454, 455, 456, 457, 458, - 0, 459, 687, 688, 0, 0, 462, 463, 691, 465, - 692, 1367, 467, 468, 694, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 699, 700, 489, 0, - 490, 702, 492, 493, 494, 495, 496, 497, 498, 0, - 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, - 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, - 717, 517, 518, 519, 520, 0, 0, 0, 0, 0, - 0, 0, 1368, 1369, 2404, 117, 0, 0, 0, 2405, - 0, 2406, 1061, 0, 0, 0, 0, 0, 0, 0, - 1105, 0, 0, 0, 118, 119, 120, 121, 122, 123, - 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, - 0, 1062, 0, 0, 129, 130, 131, 0, 132, 133, - 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, - 0, 144, 145, 146, 147, 148, 149, 1066, 790, 150, - 151, 152, 153, 154, 155, 156, 0, 157, 158, 159, - 160, 791, 0, 792, 0, 163, 164, 165, 166, 167, - 168, 169, 170, 171, 172, 0, 173, 174, 175, 176, - 177, 178, 0, 179, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 190, 191, 192, 193, 194, 0, - 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, - 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, - 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 793, 0, 229, 0, 230, 231, 232, 233, 0, - 234, 0, 235, 236, 0, 237, 238, 239, 240, 241, - 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 0, 277, 0, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 0, 0, 289, 290, 291, 292, - 0, 293, 294, 295, 296, 297, 298, 299, 300, 1082, - 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, 329, 330, - 331, 332, 0, 795, 334, 335, 336, 337, 338, 0, - 339, 340, 0, 0, 341, 342, 343, 0, 0, 344, - 345, 346, 347, 348, 349, 797, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, - 0, 362, 363, 798, 365, 366, 367, 368, 369, 370, - 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, - 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, - 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, - 398, 399, 400, 0, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, - 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, - 425, 426, 427, 428, 429, 0, 430, 431, 432, 433, - 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, - 443, 444, 445, 446, 447, 448, 800, 0, 0, 450, - 451, 0, 452, 453, 454, 455, 456, 457, 458, 0, - 459, 460, 461, 0, 0, 462, 463, 801, 465, 802, - 0, 467, 468, 803, 470, 471, 472, 473, 474, 0, - 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, - 482, 483, 484, 485, 486, 487, 488, 489, 0, 490, - 491, 492, 493, 494, 495, 496, 497, 498, 0, 0, - 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, - 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, - 517, 518, 519, 520, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 528, 1980, 0, 1100, 0, - 2140, 1981, 1061, 0, 0, 0, 1102, 1103, 1104, 1105, - 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, + 0, 0, 1102, 1103, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, + 0, 0, 1010, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, 154, 155, 156, 0, 157, 158, 159, @@ -7456,22 +7499,22 @@ static const yytype_int16 yytable[] = 186, 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, - 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, + 210, 0, 211, 212, 213, 0, 214, 215, 216, -540, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, + 227, 228, 0, 229, -540, 230, 231, 232, 233, -540, 234, 0, 235, 0, 0, 0, 238, 239, 529, 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, - 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, + -540, 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, 287, 288, 0, 0, 289, 0, 291, 0, - 0, 293, 294, 295, 296, 297, 298, 299, 300, 530, + -540, 293, 294, 295, 296, 297, 298, 299, 300, 530, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 0, 324, 325, 326, 327, 328, 0, 329, 330, - 0, 332, 0, 333, 334, 335, 336, 337, 338, 0, - 339, 340, 0, 0, 341, 342, 343, 0, 0, 344, + 0, 332, 0, 333, 334, 335, 336, 337, 338, -540, + 339, 340, 0, 0, 341, 342, 343, 0, -540, 344, 345, 346, 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, 364, 0, 366, 367, 368, 369, 370, @@ -7486,764 +7529,514 @@ static const yytype_int16 yytable[] = 443, 444, 445, 446, 531, 448, 449, 0, 0, 450, 451, 0, 452, 0, 454, 455, 456, 457, 458, 0, 459, 460, 461, 0, 0, 462, 463, 464, 465, 466, - 0, 467, 468, 469, 470, 471, 472, 473, 474, 0, + 0, 467, 468, 469, 470, 471, 472, 473, 474, -540, 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, 488, 489, 0, 490, 0, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, - 517, 518, 519, 520, 0, 0, 0, 0, 0, 528, + 517, 518, 519, 520, 528, 0, 554, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1102, 1103, 118, 119, - 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, - 0, 0, 0, 0, 0, 0, 1010, 0, 0, 130, - 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, - 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, - 149, 0, 0, 150, 151, 152, 153, 154, 155, 156, - 0, 157, 158, 159, 160, 161, 0, 0, 0, 163, - 164, 165, 166, 167, 168, 0, 170, 171, 172, 0, - 173, 174, 175, 176, 177, 178, 0, 0, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, - 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, - 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, - 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, - 214, 215, 216, -540, 217, 218, 219, 220, 221, 222, - 223, 224, 225, 226, 227, 228, 0, 229, -540, 230, - 231, 232, 233, -540, 234, 0, 235, 0, 0, 0, - 238, 239, 529, 0, 242, 0, 243, 0, 244, 245, - 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, - 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, - 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, - 273, 274, 275, 276, -540, 277, 0, 278, 0, 0, - 281, 0, 283, 284, 285, 286, 287, 288, 0, 0, - 289, 0, 291, 0, -540, 293, 294, 295, 296, 297, - 298, 299, 300, 530, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, 321, 322, 0, 324, 325, 326, 327, - 328, 0, 329, 330, 0, 332, 0, 333, 334, 335, - 336, 337, 338, -540, 339, 340, 0, 0, 341, 342, - 343, 0, -540, 344, 345, 346, 0, 348, 0, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - 361, 0, 0, 0, 0, 362, 363, 364, 0, 366, - 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, - 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, - 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, - 0, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, - 421, 422, 423, 424, 425, 426, 427, 428, 429, 0, - 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 445, 446, 531, 448, - 449, 0, 0, 450, 451, 0, 452, 0, 454, 455, - 456, 457, 458, 0, 459, 460, 461, 0, 0, 462, - 463, 464, 465, 466, 0, 467, 468, 469, 470, 471, - 472, 473, 474, -540, 0, 475, 476, 477, 0, 478, - 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, - 488, 489, 0, 490, 0, 492, 493, 494, 495, 496, - 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 516, 517, 518, 519, 520, 528, 0, - 554, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1177, 0, 118, 119, 120, - 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, - 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, - 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, - 0, 0, 150, 151, 152, 153, 154, 155, 156, 0, - 157, 158, 159, 160, 161, 0, 0, 0, 163, 164, - 165, 166, 167, 168, 0, 170, 171, 172, 0, 173, - 174, 175, 176, 177, 178, 0, 0, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, - 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, - 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, - 215, 216, 0, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, - 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, - 239, 529, 0, 242, 0, 243, 0, 244, 245, 246, - 247, 0, 248, 249, 250, 251, 252, 253, 254, 0, - 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, - 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, - 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, - 0, 283, 284, 285, 286, 287, 288, 0, 0, 289, - 0, 291, 0, 0, 293, 294, 295, 296, 297, 298, - 299, 300, 530, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 322, 0, 324, 325, 326, 327, 328, - 0, 329, 330, 0, 332, 0, 333, 334, 335, 336, - 337, 338, 0, 339, 340, 0, 0, 341, 342, 343, - 0, 0, 344, 345, 346, 0, 348, 0, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, - 0, 0, 0, 0, 362, 363, 364, 0, 366, 367, - 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, - 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, - 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 397, 398, 399, 400, 0, 401, 402, 0, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, - 422, 423, 424, 425, 426, 427, 428, 429, 0, 0, - 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, - 440, 441, 442, 443, 444, 445, 446, 531, 448, 449, - 0, 0, 450, 451, 0, 452, 0, 454, 455, 456, - 457, 458, 0, 459, 460, 461, 0, 0, 462, 463, - 464, 465, 466, 0, 467, 468, 469, 470, 471, 472, - 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, - 480, 481, 0, 482, 483, 484, 485, 486, 487, 488, - 489, 0, 490, 0, 492, 493, 494, 495, 496, 497, - 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, - 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, - 514, 515, 516, 517, 518, 519, 520, 974, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 2492, 3306, 0, 118, 119, 120, 121, - 122, 123, 124, 125, 0, 126, 127, 128, 3, 4, - 0, 565, 0, 0, 0, 0, 570, 130, 131, 0, - 132, 133, 134, 572, 136, 137, 138, 573, 574, 575, - 576, 577, 0, 144, 145, 146, 147, 148, 149, 0, - 0, 150, 151, 152, 153, 581, 582, 156, 0, 157, - 158, 159, 160, 584, 0, 586, 0, 588, 164, 165, - 166, 167, 168, 589, 170, 171, 172, 0, 173, 174, - 175, 176, 177, 178, 0, 592, 180, 181, 182, 183, - 184, 185, 186, 187, 188, 189, 594, 191, 192, 595, - 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, - 14, 15, 202, 203, 204, 205, 0, 0, 206, 207, - 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, - 216, 0, 217, 218, 219, 220, 605, 222, 223, 224, - 225, 226, 227, 606, 0, 229, 0, 230, 231, 609, - 233, 0, 234, 0, 235, 612, 23, 614, 238, 239, - 615, 616, 242, 0, 243, 0, 619, 620, 246, 247, - 0, 248, 249, 250, 251, 252, 253, 254, 622, 256, - 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, - 266, 0, 267, 625, 626, 270, 271, 272, 273, 274, - 627, 628, 0, 630, 0, 278, 632, 633, 281, 634, - 283, 284, 285, 286, 287, 288, 0, 0, 289, 637, - 291, 638, 0, 293, 294, 295, 296, 297, 298, 299, - 300, 640, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 641, 642, 643, 325, 326, 327, 644, 0, - 329, 330, 646, 332, 0, 648, 334, 649, 336, 337, - 338, 0, 339, 340, 0, 0, 341, 342, 343, 0, - 0, 344, 345, 655, 656, 348, 657, 658, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 360, 361, 26, - 27, 28, 0, 362, 363, 663, 664, 366, 367, 665, - 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, - 0, 378, 379, 380, 381, 382, 668, 384, 385, 386, - 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, - 396, 397, 398, 399, 400, 0, 401, 402, 671, 404, - 405, 406, 672, 408, 409, 410, 411, 412, 413, 414, - 415, 416, 417, 418, 419, 420, 33, 674, 421, 422, - 423, 424, 425, 426, 675, 428, 429, 35, 677, 431, - 432, 678, 434, 0, 435, 436, 437, 438, 439, 440, - 441, 442, 443, 444, 445, 446, 680, 448, 681, 37, - 0, 450, 451, 38, 452, 685, 454, 455, 456, 457, - 458, 0, 459, 687, 688, 0, 0, 462, 463, 691, - 465, 692, 0, 467, 468, 694, 470, 471, 472, 473, - 474, 0, 0, 475, 476, 477, 40, 478, 479, 480, - 481, 0, 482, 483, 484, 485, 486, 975, 700, 489, - 0, 490, 702, 492, 493, 494, 495, 496, 497, 498, - 0, 0, 499, 0, 44, 500, 501, 502, 503, 504, - 505, 707, 708, 709, 710, 711, 712, 713, 714, 715, - 716, 717, 517, 518, 519, 520, 0, 117, 45, 554, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 46, 0, 0, 0, 118, 119, 120, 121, - 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, - 0, 0, 0, 0, 0, 0, 129, 130, 131, 0, - 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, - 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, - 790, 150, 151, 152, 153, 154, 155, 156, 0, 157, - 158, 159, 160, 791, 0, 792, 0, 163, 164, 165, - 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, - 175, 176, 177, 178, 0, 179, 180, 181, 182, 183, - 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, - 14, 15, 202, 203, 204, 205, 0, 0, 206, 207, - 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, - 216, 0, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 793, 0, 229, 0, 230, 231, 232, - 233, 0, 234, 0, 235, 236, 23, 237, 238, 239, - 240, 241, 242, 0, 243, 0, 244, 245, 246, 247, - 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, - 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 0, 277, 0, 278, 279, 280, 281, 282, - 283, 284, 285, 286, 287, 288, 794, 0, 289, 290, - 291, 292, 0, 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, 0, - 329, 330, 331, 332, 0, 795, 334, 335, 336, 337, - 338, 0, 339, 340, 0, 796, 341, 342, 343, 0, - 0, 344, 345, 346, 347, 348, 349, 797, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 360, 361, 26, - 27, 28, 0, 362, 363, 798, 365, 366, 367, 368, - 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, - 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, - 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, - 396, 397, 398, 399, 400, 0, 401, 402, 403, 404, - 405, 406, 407, 799, 409, 410, 411, 412, 413, 414, - 415, 416, 417, 418, 419, 420, 33, 0, 421, 422, - 423, 424, 425, 426, 427, 428, 429, 35, 430, 431, - 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, - 441, 442, 443, 444, 445, 446, 447, 448, 800, 37, - 0, 450, 451, 38, 452, 453, 454, 455, 456, 457, - 458, 0, 459, 460, 461, 0, 0, 462, 463, 801, - 465, 802, 0, 467, 468, 803, 470, 471, 472, 473, - 474, 0, 0, 475, 476, 477, 40, 478, 479, 480, - 481, 0, 482, 483, 484, 485, 486, 804, 488, 489, - 0, 490, 491, 492, 493, 494, 495, 496, 497, 498, - 0, 0, 499, 0, 44, 500, 501, 502, 503, 504, - 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, - 515, 516, 517, 518, 519, 520, 0, 117, 45, 554, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 805, 0, 0, 0, 118, 119, 120, 121, - 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, - 0, 0, 0, 0, 0, 0, 129, 130, 131, 0, - 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, - 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, - 790, 150, 151, 152, 153, 154, 155, 156, 0, 157, - 158, 159, 160, 791, 0, 792, 0, 163, 164, 165, - 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, - 175, 176, 177, 178, 0, 179, 180, 181, 182, 183, - 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, - 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, - 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, - 216, 0, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 793, 0, 229, 0, 230, 231, 232, - 233, 0, 234, 0, 235, 236, 0, 237, 238, 239, - 240, 241, 242, 0, 243, 0, 244, 245, 246, 247, - 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, - 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 0, 277, 0, 278, 279, 280, 281, 282, - 283, 284, 285, 286, 287, 288, 794, 0, 289, 290, - 291, 292, 0, 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, 0, - 329, 330, 331, 332, 0, 795, 334, 335, 336, 337, - 338, 0, 339, 340, 0, 796, 341, 342, 343, 0, - 0, 344, 345, 346, 347, 348, 349, 797, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, - 0, 0, 0, 362, 363, 798, 365, 366, 367, 368, - 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, - 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, - 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, - 396, 397, 398, 399, 400, 0, 401, 402, 403, 404, - 405, 406, 407, 799, 409, 410, 411, 412, 413, 414, - 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, - 423, 424, 425, 426, 427, 428, 429, 0, 430, 431, - 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, - 441, 442, 443, 444, 445, 446, 447, 448, 800, 0, - 0, 450, 451, 0, 452, 453, 454, 455, 456, 457, - 458, 0, 459, 460, 461, 0, 0, 462, 463, 801, - 465, 802, 0, 467, 468, 803, 470, 471, 472, 473, - 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, - 481, 0, 482, 483, 484, 485, 486, 804, 488, 489, - 0, 490, 491, 492, 493, 494, 495, 496, 497, 498, - 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, - 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, - 515, 516, 517, 518, 519, 520, 117, 0, 554, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 805, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 0, 0, 0, 0, 0, 129, 130, 131, 0, 132, - 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, - 143, 0, 144, 145, 146, 147, 148, 149, 0, 790, - 150, 151, 152, 153, 154, 155, 156, 0, 157, 158, - 159, 160, 791, 0, 792, 0, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 227, 793, 0, 229, 0, 230, 231, 232, 233, - 0, 234, 0, 235, 236, 0, 237, 238, 239, 240, - 241, 242, 0, 243, 0, 244, 245, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 268, 269, 270, 271, 272, 273, 274, 275, - 276, 0, 277, 0, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 290, 291, - 292, 0, 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, 0, 329, - 330, 331, 332, 0, 795, 334, 335, 336, 337, 338, - 0, 339, 340, 0, 796, 341, 342, 343, 0, 0, - 344, 345, 346, 347, 348, 349, 797, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 798, 365, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 403, 404, 405, - 406, 407, 799, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 430, 431, 432, - 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 447, 448, 800, 0, 0, - 450, 451, 0, 452, 453, 454, 455, 456, 457, 458, - 0, 459, 460, 461, 0, 0, 462, 463, 801, 465, - 802, 0, 467, 468, 803, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 488, 489, 0, - 490, 491, 492, 493, 494, 495, 496, 497, 498, 0, - 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 520, 117, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1018, 0, 0, 118, 119, 120, 121, 122, 123, - 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, - 0, 0, 0, 0, 129, 130, 131, 0, 132, 133, - 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, - 0, 144, 145, 146, 147, 148, 149, 0, 790, 150, - 151, 152, 153, 154, 155, 156, 0, 157, 158, 159, - 160, 791, 0, 792, 0, 163, 164, 165, 166, 167, - 168, 169, 170, 171, 172, 0, 173, 174, 175, 176, - 177, 178, 0, 179, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 190, 191, 192, 193, 194, 0, - 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, - 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, - 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 793, 0, 229, 0, 230, 231, 232, 233, 0, - 234, 0, 235, 236, 0, 237, 238, 239, 240, 241, - 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 0, 277, 0, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 0, 0, 289, 290, 291, 292, - 0, 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, 0, 329, 330, - 331, 332, 0, 795, 334, 335, 336, 337, 338, 0, - 339, 340, 0, 0, 341, 342, 343, 0, 0, 344, - 345, 346, 347, 348, 349, 797, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, - 0, 362, 363, 798, 365, 366, 367, 368, 369, 370, - 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, - 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, - 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, - 398, 399, 400, 0, 401, 402, 403, 404, 405, 406, - 407, 799, 409, 410, 411, 412, 413, 414, 415, 416, - 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, - 425, 426, 427, 428, 429, 0, 430, 431, 432, 433, - 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, - 443, 444, 445, 446, 447, 448, 800, 0, 0, 450, - 451, 0, 452, 453, 454, 455, 456, 457, 458, 0, - 459, 460, 461, 0, 0, 462, 463, 801, 465, 802, - 0, 467, 468, 803, 470, 471, 472, 473, 474, 0, - 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, - 482, 483, 484, 485, 486, 487, 488, 489, 0, 490, - 491, 492, 493, 494, 495, 496, 497, 498, 0, 0, - 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, - 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, - 517, 518, 519, 520, 117, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 46, 0, 0, 118, 119, 120, 121, 122, 123, 124, + 0, 1177, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, - 0, 0, 0, 129, 130, 131, 0, 132, 133, 134, - 135, 136, 137, 138, 139, 140, 141, 142, 143, 0, - 144, 145, 146, 147, 148, 149, 0, 790, 150, 151, + 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, + 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, + 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, 154, 155, 156, 0, 157, 158, 159, 160, - 791, 0, 792, 0, 163, 164, 165, 166, 167, 168, - 169, 170, 171, 172, 0, 173, 174, 175, 176, 177, - 178, 0, 179, 180, 181, 182, 183, 184, 185, 186, + 161, 0, 0, 0, 163, 164, 165, 166, 167, 168, + 0, 170, 171, 172, 0, 173, 174, 175, 176, 177, + 178, 0, 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 793, 0, 229, 0, 230, 231, 232, 233, 0, 234, - 0, 235, 236, 0, 237, 238, 239, 240, 241, 242, + 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, + 0, 235, 0, 0, 0, 238, 239, 529, 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 250, 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, - 268, 269, 270, 271, 272, 273, 274, 275, 276, 0, - 277, 0, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 0, 0, 289, 290, 291, 292, 0, - 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, 0, 329, 330, 331, - 332, 0, 795, 334, 335, 336, 337, 338, 0, 339, + 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, + 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, + 286, 287, 288, 0, 0, 289, 0, 291, 0, 0, + 293, 294, 295, 296, 297, 298, 299, 300, 530, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, + 0, 324, 325, 326, 327, 328, 0, 329, 330, 0, + 332, 0, 333, 334, 335, 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, 343, 0, 0, 344, 345, - 346, 347, 348, 349, 797, 351, 352, 353, 354, 355, + 346, 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, - 362, 363, 798, 365, 366, 367, 368, 369, 370, 371, + 362, 363, 364, 0, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, - 399, 400, 0, 401, 402, 403, 404, 405, 406, 407, + 399, 400, 0, 401, 402, 0, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, - 426, 427, 428, 429, 0, 430, 431, 432, 433, 434, + 426, 427, 428, 429, 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, - 444, 445, 446, 447, 448, 800, 0, 0, 450, 451, - 0, 452, 453, 454, 455, 456, 457, 458, 0, 459, - 460, 461, 0, 0, 462, 463, 801, 465, 802, 0, - 467, 468, 803, 470, 471, 472, 473, 474, 0, 0, + 444, 445, 446, 531, 448, 449, 0, 0, 450, 451, + 0, 452, 0, 454, 455, 456, 457, 458, 0, 459, + 460, 461, 0, 0, 462, 463, 464, 465, 466, 0, + 467, 468, 469, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, - 483, 484, 485, 486, 487, 488, 489, 0, 490, 491, + 483, 484, 485, 486, 487, 488, 489, 0, 490, 0, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, - 518, 519, 520, 528, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 3395, - 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, - 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, - 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, + 518, 519, 520, 974, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 2495, + 3307, 0, 118, 119, 120, 121, 122, 123, 124, 125, + 0, 126, 127, 128, 3, 4, 0, 565, 0, 0, + 0, 0, 570, 130, 131, 0, 132, 133, 134, 572, + 136, 137, 138, 573, 574, 575, 576, 577, 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, - 153, 154, 155, 156, 0, 157, 158, 159, 160, 161, - 0, 0, 0, 163, 164, 165, 166, 167, 168, 0, + 153, 581, 582, 156, 0, 157, 158, 159, 160, 584, + 0, 586, 0, 588, 164, 165, 166, 167, 168, 589, 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, - 0, 0, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, + 0, 592, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 594, 191, 192, 595, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 14, 15, 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, - 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, - 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, - 235, 0, 23, 0, 238, 239, 529, 0, 242, 0, - 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, - 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, - 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, - 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, - 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, - 287, 288, 0, 0, 289, 0, 291, 0, 0, 293, - 294, 295, 296, 297, 298, 299, 300, 530, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 321, 322, 0, - 324, 325, 326, 327, 328, 0, 329, 330, 0, 332, - 0, 333, 334, 335, 336, 337, 338, 0, 339, 340, - 0, 0, 341, 342, 343, 0, 0, 344, 345, 346, - 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, 361, 26, 27, 28, 0, 362, - 363, 364, 0, 366, 367, 368, 369, 370, 371, 0, - 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, - 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, - 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, - 400, 0, 401, 402, 0, 404, 405, 406, 407, 408, - 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, - 419, 420, 33, 0, 421, 422, 423, 424, 425, 426, - 427, 428, 429, 35, 0, 431, 432, 433, 434, 0, - 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, - 445, 446, 531, 448, 449, 37, 0, 450, 451, 38, - 452, 0, 454, 455, 456, 457, 458, 0, 459, 460, - 461, 0, 0, 462, 463, 464, 465, 466, 0, 467, - 468, 469, 470, 471, 472, 473, 474, 0, 0, 475, - 476, 477, 40, 478, 479, 480, 481, 0, 482, 483, - 484, 485, 486, 804, 488, 489, 0, 490, 0, 492, - 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, - 44, 500, 501, 502, 503, 504, 505, 506, 507, 508, - 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, - 519, 520, 0, 528, 45, 554, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 46, 0, - 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, - 894, 126, 127, 128, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, - 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, - 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, - 153, 154, 155, 156, 0, 157, 158, 159, 160, 161, - 0, 0, 0, 163, 164, 165, 166, 167, 168, 0, - 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, - 0, 0, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, - 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, - 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, - 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, - 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, - 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, - 235, 0, 23, 0, 238, 239, 529, 0, 242, 0, - 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, - 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, - 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, - 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, - 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, - 287, 288, 0, 0, 289, 0, 291, 0, 0, 293, - 294, 295, 296, 297, 298, 299, 300, 530, 302, 303, + 219, 220, 605, 222, 223, 224, 225, 226, 227, 606, + 0, 229, 0, 230, 231, 609, 233, 0, 234, 0, + 235, 612, 23, 614, 238, 239, 615, 616, 242, 0, + 243, 0, 619, 620, 246, 247, 0, 248, 249, 250, + 251, 252, 253, 254, 622, 256, 257, 258, 259, 0, + 260, 261, 262, 263, 264, 265, 266, 0, 267, 625, + 626, 270, 271, 272, 273, 274, 627, 628, 0, 630, + 0, 278, 632, 633, 281, 634, 283, 284, 285, 286, + 287, 288, 0, 0, 289, 637, 291, 638, 0, 293, + 294, 295, 296, 297, 298, 299, 300, 640, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 321, 322, 0, - 324, 325, 326, 327, 328, 0, 329, 330, 0, 332, - 0, 333, 334, 335, 336, 337, 338, 0, 339, 340, - 0, 0, 341, 342, 343, 0, 0, 344, 345, 346, - 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, + 314, 315, 316, 317, 318, 319, 320, 321, 641, 642, + 643, 325, 326, 327, 644, 0, 329, 330, 646, 332, + 0, 648, 334, 649, 336, 337, 338, 0, 339, 340, + 0, 0, 341, 342, 343, 0, 0, 344, 345, 655, + 656, 348, 657, 658, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 26, 27, 28, 0, 362, - 363, 364, 0, 366, 367, 368, 369, 370, 371, 0, + 363, 663, 664, 366, 367, 665, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, - 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, + 381, 382, 668, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, - 400, 0, 401, 402, 0, 404, 405, 406, 407, 408, + 400, 0, 401, 402, 671, 404, 405, 406, 672, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, - 419, 420, 33, 0, 421, 422, 423, 424, 425, 426, - 427, 428, 429, 0, 0, 431, 432, 433, 434, 0, + 419, 420, 33, 674, 421, 422, 423, 424, 425, 426, + 675, 428, 429, 35, 677, 431, 432, 678, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, - 445, 446, 531, 448, 449, 0, 0, 450, 451, 38, - 452, 0, 454, 455, 456, 457, 458, 0, 459, 895, - 461, 0, 0, 896, 463, 464, 465, 466, 0, 467, - 468, 469, 470, 471, 472, 473, 474, 0, 0, 475, + 445, 446, 680, 448, 681, 37, 0, 450, 451, 38, + 452, 685, 454, 455, 456, 457, 458, 0, 459, 687, + 688, 0, 0, 462, 463, 691, 465, 692, 0, 467, + 468, 694, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 40, 478, 479, 480, 481, 0, 482, 483, - 484, 485, 486, 804, 488, 489, 0, 490, 0, 492, + 484, 485, 486, 975, 700, 489, 0, 490, 702, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, - 44, 500, 501, 502, 503, 504, 505, 506, 507, 508, - 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, - 519, 520, 0, 528, 45, 554, 0, 0, 0, 0, + 44, 500, 501, 502, 503, 504, 505, 707, 708, 709, + 710, 711, 712, 713, 714, 715, 716, 717, 517, 518, + 519, 520, 0, 117, 45, 554, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 46, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, - 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, - 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, - 153, 154, 155, 156, 0, 157, 158, 159, 160, 161, - 0, 0, 0, 163, 164, 165, 166, 167, 168, 0, + 0, 0, 129, 130, 131, 0, 132, 133, 134, 135, + 136, 137, 138, 139, 140, 141, 142, 143, 0, 144, + 145, 146, 147, 148, 149, 0, 790, 150, 151, 152, + 153, 154, 155, 156, 0, 157, 158, 159, 160, 791, + 0, 792, 0, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, - 0, 0, 180, 181, 182, 183, 184, 185, 186, 187, + 0, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, - 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, + 196, 197, 198, 199, 200, 201, 14, 15, 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, - 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 793, 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, - 235, 0, 23, 0, 238, 239, 529, 0, 242, 0, + 235, 236, 23, 237, 238, 239, 240, 241, 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, - 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, - 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 0, + 260, 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, - 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, - 287, 288, 0, 0, 289, 0, 291, 0, 0, 293, - 294, 295, 296, 297, 298, 299, 300, 530, 302, 303, + 0, 278, 279, 280, 281, 282, 283, 284, 285, 286, + 287, 288, 794, 0, 289, 290, 291, 292, 0, 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, 0, - 324, 325, 326, 327, 328, 0, 329, 330, 0, 332, - 0, 333, 334, 335, 336, 337, 338, 0, 339, 340, - 0, 0, 341, 342, 343, 0, 0, 344, 345, 346, - 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, + 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, + 324, 325, 326, 327, 328, 0, 329, 330, 331, 332, + 0, 795, 334, 335, 336, 337, 338, 0, 339, 340, + 0, 796, 341, 342, 343, 0, 0, 344, 345, 346, + 347, 348, 349, 797, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 26, 27, 28, 0, 362, - 363, 364, 0, 366, 367, 368, 369, 370, 371, 0, + 363, 798, 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, - 400, 0, 401, 402, 0, 404, 405, 406, 407, 408, + 400, 0, 401, 402, 403, 404, 405, 406, 407, 799, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 33, 0, 421, 422, 423, 424, 425, 426, - 427, 428, 429, 0, 0, 431, 432, 433, 434, 0, + 427, 428, 429, 35, 430, 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, - 445, 446, 531, 448, 449, 0, 0, 450, 451, 38, - 452, 0, 454, 455, 456, 457, 458, 0, 459, 460, - 461, 0, 0, 462, 463, 464, 465, 466, 0, 467, - 468, 469, 470, 471, 472, 473, 474, 0, 0, 475, + 445, 446, 447, 448, 800, 37, 0, 450, 451, 38, + 452, 453, 454, 455, 456, 457, 458, 0, 459, 460, + 461, 0, 0, 462, 463, 801, 465, 802, 0, 467, + 468, 803, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 40, 478, 479, 480, 481, 0, 482, 483, - 484, 485, 486, 804, 488, 489, 0, 490, 0, 492, + 484, 485, 486, 804, 488, 489, 0, 490, 491, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 44, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, - 519, 520, 0, 528, 45, 554, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 46, 0, + 519, 520, 0, 117, 45, 554, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 805, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, - 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, - 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, - 153, 154, 155, 156, 0, 157, 158, 159, 160, 161, - 0, 0, 0, 163, 164, 165, 166, 167, 168, 0, + 0, 0, 129, 130, 131, 0, 132, 133, 134, 135, + 136, 137, 138, 139, 140, 141, 142, 143, 0, 144, + 145, 146, 147, 148, 149, 0, 790, 150, 151, 152, + 153, 154, 155, 156, 0, 157, 158, 159, 160, 791, + 0, 792, 0, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, - 0, 0, 180, 181, 182, 183, 184, 185, 186, 187, + 0, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, - 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 793, 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, - 235, 0, 0, 0, 238, 239, 529, 0, 242, 0, + 235, 236, 0, 237, 238, 239, 240, 241, 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, - 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, - 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 0, + 260, 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, - 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, - 287, 288, 0, 0, 289, 0, 291, 0, 0, 293, - 294, 295, 296, 297, 298, 299, 300, 530, 302, 303, + 0, 278, 279, 280, 281, 282, 283, 284, 285, 286, + 287, 288, 794, 0, 289, 290, 291, 292, 0, 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, 0, - 324, 325, 326, 327, 328, 0, 329, 330, 0, 332, - 0, 333, 334, 335, 336, 337, 338, 0, 339, 340, - 0, 0, 341, 342, 343, 0, 0, 344, 345, 346, - 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, + 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, + 324, 325, 326, 327, 328, 0, 329, 330, 331, 332, + 0, 795, 334, 335, 336, 337, 338, 0, 339, 340, + 0, 796, 341, 342, 343, 0, 0, 344, 345, 346, + 347, 348, 349, 797, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, - 363, 364, 0, 366, 367, 368, 369, 370, 371, 0, + 363, 798, 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, - 400, 0, 401, 402, 0, 404, 405, 406, 407, 408, + 400, 0, 401, 402, 403, 404, 405, 406, 407, 799, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, 426, - 427, 428, 429, 0, 0, 431, 432, 433, 434, 0, + 427, 428, 429, 0, 430, 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, - 445, 446, 531, 448, 449, 0, 0, 450, 451, 0, - 452, 0, 454, 455, 456, 457, 458, 0, 459, 460, - 461, 0, 0, 462, 463, 464, 465, 466, 0, 467, - 468, 469, 470, 471, 472, 473, 474, 0, 0, 475, + 445, 446, 447, 448, 800, 0, 0, 450, 451, 0, + 452, 453, 454, 455, 456, 457, 458, 0, 459, 460, + 461, 0, 0, 462, 463, 801, 465, 802, 0, 467, + 468, 803, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, - 484, 485, 486, 487, 488, 489, 0, 490, 0, 492, + 484, 485, 486, 804, 488, 489, 0, 490, 491, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, - 519, 520, 528, 0, 554, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 994, 0, + 519, 520, 117, 0, 554, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 805, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, - 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, - 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, - 154, 155, 156, 0, 157, 158, 159, 160, 161, 0, - 0, 0, 163, 164, 165, 166, 167, 168, 0, 170, + 0, 129, 130, 131, 0, 132, 133, 134, 135, 136, + 137, 138, 139, 140, 141, 142, 143, 0, 144, 145, + 146, 147, 148, 149, 0, 790, 150, 151, 152, 153, + 154, 155, 156, 0, 157, 158, 159, 160, 791, 0, + 792, 0, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, - 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 0, + 220, 221, 222, 223, 224, 225, 226, 227, 793, 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, - 0, 0, 0, 238, 239, 529, 0, 242, 0, 243, + 236, 0, 237, 238, 239, 240, 241, 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, 251, - 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, - 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, + 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, - 278, 0, 0, 281, 0, 283, 284, 285, 286, 287, - 288, 0, 0, 289, 0, 291, 0, 0, 293, 294, - 295, 296, 297, 298, 299, 300, 530, 302, 303, 304, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 0, 0, 289, 290, 291, 292, 0, 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, 0, 324, - 325, 326, 327, 328, 0, 329, 330, 0, 332, 0, - 333, 334, 335, 336, 337, 338, 0, 339, 340, 0, - 0, 341, 342, 343, 0, 0, 344, 345, 346, 0, - 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, + 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, 0, 329, 330, 331, 332, 0, + 795, 334, 335, 336, 337, 338, 0, 339, 340, 0, + 796, 341, 342, 343, 0, 0, 344, 345, 346, 347, + 348, 349, 797, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, - 364, 0, 366, 367, 368, 369, 370, 371, 0, 372, + 798, 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, - 0, 401, 402, 0, 404, 405, 406, 407, 408, 409, + 0, 401, 402, 403, 404, 405, 406, 407, 799, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, - 428, 429, 0, 0, 431, 432, 433, 434, 0, 435, + 428, 429, 0, 430, 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, - 446, 531, 448, 449, 0, 0, 450, 451, 0, 452, - 0, 454, 455, 456, 457, 458, 0, 459, 460, 461, - 0, 0, 462, 463, 464, 465, 466, 0, 467, 468, - 469, 470, 471, 472, 473, 474, 0, 0, 475, 476, + 446, 447, 448, 800, 0, 0, 450, 451, 0, 452, + 453, 454, 455, 456, 457, 458, 0, 459, 460, 461, + 0, 0, 462, 463, 801, 465, 802, 0, 467, 468, + 803, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, - 485, 486, 487, 488, 489, 0, 490, 0, 492, 493, + 485, 486, 487, 488, 489, 0, 490, 491, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, - 520, 528, 0, 554, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1493, 0, 0, + 520, 117, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1018, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, - 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, - 147, 148, 149, 0, 0, 150, 151, 152, 153, 154, - 155, 156, 0, 157, 158, 159, 160, 161, 0, 0, - 0, 163, 164, 165, 166, 167, 168, 0, 170, 171, - 172, 0, 173, 174, 175, 176, 177, 178, 0, 0, + 129, 130, 131, 0, 132, 133, 134, 135, 136, 137, + 138, 139, 140, 141, 142, 143, 0, 144, 145, 146, + 147, 148, 149, 0, 790, 150, 151, 152, 153, 154, + 155, 156, 0, 157, 158, 159, 160, 791, 0, 792, + 0, 163, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 0, 173, 174, 175, 176, 177, 178, 0, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 227, 228, 0, 229, - 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, - 0, 0, 238, 239, 529, 0, 242, 0, 243, 0, + 221, 222, 223, 224, 225, 226, 227, 793, 0, 229, + 0, 230, 231, 232, 233, 0, 234, 0, 235, 236, + 0, 237, 238, 239, 240, 241, 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, 251, 252, - 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, - 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, + 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, + 262, 263, 264, 265, 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, - 0, 0, 281, 0, 283, 284, 285, 286, 287, 288, - 0, 0, 289, 0, 291, 0, 0, 293, 294, 295, - 296, 297, 298, 299, 300, 530, 302, 303, 304, 305, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 0, 0, 289, 290, 291, 292, 0, 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, 0, 324, 325, - 326, 327, 328, 0, 329, 330, 0, 332, 0, 333, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, 0, 329, 330, 331, 332, 0, 795, 334, 335, 336, 337, 338, 0, 339, 340, 0, 0, - 341, 342, 343, 0, 0, 344, 345, 346, 0, 348, - 0, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, 361, 0, 0, 0, 0, 362, 363, 364, - 0, 366, 367, 368, 369, 370, 371, 0, 372, 373, + 341, 342, 343, 0, 0, 344, 345, 346, 347, 348, + 349, 797, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 360, 361, 0, 0, 0, 0, 362, 363, 798, + 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, - 401, 402, 0, 404, 405, 406, 407, 408, 409, 410, + 401, 402, 403, 404, 405, 406, 407, 799, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, - 429, 0, 0, 431, 432, 433, 434, 0, 435, 436, + 429, 0, 430, 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - 531, 448, 449, 0, 0, 450, 451, 0, 452, 0, + 447, 448, 800, 0, 0, 450, 451, 0, 452, 453, 454, 455, 456, 457, 458, 0, 459, 460, 461, 0, - 0, 462, 463, 464, 465, 466, 0, 467, 468, 469, + 0, 462, 463, 801, 465, 802, 0, 467, 468, 803, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, - 486, 487, 488, 489, 0, 490, 0, 492, 493, 494, + 486, 487, 488, 489, 0, 490, 491, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, - 528, 0, 554, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 2101, 0, 0, 118, + 117, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 46, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, - 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, - 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, - 148, 149, 0, 0, 150, 151, 152, 153, 154, 155, - 156, 0, 157, 158, 159, 160, 161, 0, 0, 0, - 163, 164, 165, 166, 167, 168, 0, 170, 171, 172, - 0, 173, 174, 175, 176, 177, 178, 0, 0, 180, + 128, 0, 0, 0, 0, 0, 0, 0, 0, 129, + 130, 131, 0, 132, 133, 134, 135, 136, 137, 138, + 139, 140, 141, 142, 143, 0, 144, 145, 146, 147, + 148, 149, 0, 790, 150, 151, 152, 153, 154, 155, + 156, 0, 157, 158, 159, 160, 791, 0, 792, 0, + 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, + 0, 173, 174, 175, 176, 177, 178, 0, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 221, - 222, 223, 224, 225, 226, 227, 228, 0, 229, 0, - 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, - 0, 238, 239, 529, 0, 242, 0, 243, 0, 244, + 222, 223, 224, 225, 226, 227, 793, 0, 229, 0, + 230, 231, 232, 233, 0, 234, 0, 235, 236, 0, + 237, 238, 239, 240, 241, 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, 251, 252, 253, - 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, - 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, - 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, - 0, 281, 0, 283, 284, 285, 286, 287, 288, 0, - 0, 289, 0, 291, 0, 0, 293, 294, 295, 296, - 297, 298, 299, 300, 530, 302, 303, 304, 305, 306, + 254, 255, 256, 257, 258, 259, 0, 260, 261, 262, + 263, 264, 265, 266, 0, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 0, 277, 0, 278, 279, + 280, 281, 282, 283, 284, 285, 286, 287, 288, 0, + 0, 289, 290, 291, 292, 0, 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, 0, 324, 325, 326, - 327, 328, 0, 329, 330, 0, 332, 0, 333, 334, + 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, + 327, 328, 0, 329, 330, 331, 332, 0, 795, 334, 335, 336, 337, 338, 0, 339, 340, 0, 0, 341, - 342, 343, 0, 0, 344, 345, 346, 0, 348, 0, - 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, 361, 0, 0, 0, 0, 362, 363, 364, 0, + 342, 343, 0, 0, 344, 345, 346, 347, 348, 349, + 797, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, 361, 0, 0, 0, 0, 362, 363, 798, 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, - 402, 0, 404, 405, 406, 407, 408, 409, 410, 411, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, 429, - 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, - 438, 439, 440, 441, 442, 443, 444, 445, 446, 531, - 448, 449, 0, 0, 450, 451, 0, 452, 0, 454, + 0, 430, 431, 432, 433, 434, 0, 435, 436, 437, + 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, + 448, 800, 0, 0, 450, 451, 0, 452, 453, 454, 455, 456, 457, 458, 0, 459, 460, 461, 0, 0, - 462, 463, 464, 465, 466, 0, 467, 468, 469, 470, + 462, 463, 801, 465, 802, 0, 467, 468, 803, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, - 487, 488, 489, 0, 490, 0, 492, 493, 494, 495, + 487, 488, 489, 0, 490, 491, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 528, - 0, 554, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 2248, 0, 0, 118, 119, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3396, 0, 0, 118, 119, + 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, + 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, + 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, + 149, 0, 0, 150, 151, 152, 153, 154, 155, 156, + 0, 157, 158, 159, 160, 161, 0, 0, 0, 163, + 164, 165, 166, 167, 168, 0, 170, 171, 172, 0, + 173, 174, 175, 176, 177, 178, 0, 0, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, + 200, 201, 14, 15, 202, 203, 204, 205, 0, 0, + 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, + 214, 215, 216, 0, 217, 218, 219, 220, 221, 222, + 223, 224, 225, 226, 227, 228, 0, 229, 0, 230, + 231, 232, 233, 0, 234, 0, 235, 0, 23, 0, + 238, 239, 529, 0, 242, 0, 243, 0, 244, 245, + 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, + 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, + 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, + 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, + 281, 0, 283, 284, 285, 286, 287, 288, 0, 0, + 289, 0, 291, 0, 0, 293, 294, 295, 296, 297, + 298, 299, 300, 530, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 0, 324, 325, 326, 327, + 328, 0, 329, 330, 0, 332, 0, 333, 334, 335, + 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, + 343, 0, 0, 344, 345, 346, 0, 348, 0, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + 361, 26, 27, 28, 0, 362, 363, 364, 0, 366, + 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, + 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, + 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, + 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, + 0, 404, 405, 406, 407, 408, 409, 410, 411, 412, + 413, 414, 415, 416, 417, 418, 419, 420, 33, 0, + 421, 422, 423, 424, 425, 426, 427, 428, 429, 35, + 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, + 439, 440, 441, 442, 443, 444, 445, 446, 531, 448, + 449, 37, 0, 450, 451, 38, 452, 0, 454, 455, + 456, 457, 458, 0, 459, 460, 461, 0, 0, 462, + 463, 464, 465, 466, 0, 467, 468, 469, 470, 471, + 472, 473, 474, 0, 0, 475, 476, 477, 40, 478, + 479, 480, 481, 0, 482, 483, 484, 485, 486, 804, + 488, 489, 0, 490, 0, 492, 493, 494, 495, 496, + 497, 498, 0, 0, 499, 0, 44, 500, 501, 502, + 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, + 513, 514, 515, 516, 517, 518, 519, 520, 0, 528, + 45, 554, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 46, 0, 0, 0, 118, 119, + 120, 121, 122, 123, 124, 125, 894, 126, 127, 128, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, + 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, + 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, + 149, 0, 0, 150, 151, 152, 153, 154, 155, 156, + 0, 157, 158, 159, 160, 161, 0, 0, 0, 163, + 164, 165, 166, 167, 168, 0, 170, 171, 172, 0, + 173, 174, 175, 176, 177, 178, 0, 0, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, + 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, + 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, + 214, 215, 216, 0, 217, 218, 219, 220, 221, 222, + 223, 224, 225, 226, 227, 228, 0, 229, 0, 230, + 231, 232, 233, 0, 234, 0, 235, 0, 23, 0, + 238, 239, 529, 0, 242, 0, 243, 0, 244, 245, + 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, + 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, + 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, + 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, + 281, 0, 283, 284, 285, 286, 287, 288, 0, 0, + 289, 0, 291, 0, 0, 293, 294, 295, 296, 297, + 298, 299, 300, 530, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 0, 324, 325, 326, 327, + 328, 0, 329, 330, 0, 332, 0, 333, 334, 335, + 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, + 343, 0, 0, 344, 345, 346, 0, 348, 0, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + 361, 26, 27, 28, 0, 362, 363, 364, 0, 366, + 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, + 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, + 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, + 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, + 0, 404, 405, 406, 407, 408, 409, 410, 411, 412, + 413, 414, 415, 416, 417, 418, 419, 420, 33, 0, + 421, 422, 423, 424, 425, 426, 427, 428, 429, 0, + 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, + 439, 440, 441, 442, 443, 444, 445, 446, 531, 448, + 449, 0, 0, 450, 451, 38, 452, 0, 454, 455, + 456, 457, 458, 0, 459, 895, 461, 0, 0, 896, + 463, 464, 465, 466, 0, 467, 468, 469, 470, 471, + 472, 473, 474, 0, 0, 475, 476, 477, 40, 478, + 479, 480, 481, 0, 482, 483, 484, 485, 486, 804, + 488, 489, 0, 490, 0, 492, 493, 494, 495, 496, + 497, 498, 0, 0, 499, 0, 44, 500, 501, 502, + 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, + 513, 514, 515, 516, 517, 518, 519, 520, 0, 528, + 45, 554, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 46, 0, 0, 0, 118, 119, + 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, + 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, + 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, + 149, 0, 0, 150, 151, 152, 153, 154, 155, 156, + 0, 157, 158, 159, 160, 161, 0, 0, 0, 163, + 164, 165, 166, 167, 168, 0, 170, 171, 172, 0, + 173, 174, 175, 176, 177, 178, 0, 0, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, + 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, + 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, + 214, 215, 216, 0, 217, 218, 219, 220, 221, 222, + 223, 224, 225, 226, 227, 228, 0, 229, 0, 230, + 231, 232, 233, 0, 234, 0, 235, 0, 23, 0, + 238, 239, 529, 0, 242, 0, 243, 0, 244, 245, + 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, + 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, + 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, + 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, + 281, 0, 283, 284, 285, 286, 287, 288, 0, 0, + 289, 0, 291, 0, 0, 293, 294, 295, 296, 297, + 298, 299, 300, 530, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 0, 324, 325, 326, 327, + 328, 0, 329, 330, 0, 332, 0, 333, 334, 335, + 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, + 343, 0, 0, 344, 345, 346, 0, 348, 0, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + 361, 26, 27, 28, 0, 362, 363, 364, 0, 366, + 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, + 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, + 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, + 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, + 0, 404, 405, 406, 407, 408, 409, 410, 411, 412, + 413, 414, 415, 416, 417, 418, 419, 420, 33, 0, + 421, 422, 423, 424, 425, 426, 427, 428, 429, 0, + 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, + 439, 440, 441, 442, 443, 444, 445, 446, 531, 448, + 449, 0, 0, 450, 451, 38, 452, 0, 454, 455, + 456, 457, 458, 0, 459, 460, 461, 0, 0, 462, + 463, 464, 465, 466, 0, 467, 468, 469, 470, 471, + 472, 473, 474, 0, 0, 475, 476, 477, 40, 478, + 479, 480, 481, 0, 482, 483, 484, 485, 486, 804, + 488, 489, 0, 490, 0, 492, 493, 494, 495, 496, + 497, 498, 0, 0, 499, 0, 44, 500, 501, 502, + 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, + 513, 514, 515, 516, 517, 518, 519, 520, 0, 528, + 45, 554, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 46, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, @@ -8293,7 +8086,7 @@ static const yytype_int16 yytable[] = 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 528, 0, 554, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 2492, 0, 0, 118, 119, 120, + 0, 0, 0, 0, 994, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, @@ -8343,7 +8136,7 @@ static const yytype_int16 yytable[] = 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 528, 0, 554, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 2633, 0, 0, 118, 119, 120, 121, + 0, 0, 0, 1493, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, @@ -8393,7 +8186,7 @@ static const yytype_int16 yytable[] = 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 528, 0, 554, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 2846, 0, 0, 118, 119, 120, 121, 122, + 0, 0, 2103, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, @@ -8441,9 +8234,9 @@ static const yytype_int16 yytable[] = 490, 0, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 520, 528, 0, 0, 0, 0, + 516, 517, 518, 519, 520, 528, 0, 554, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 3301, 0, 0, 118, 119, 120, 121, 122, 123, + 0, 2250, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, @@ -8491,109 +8284,9 @@ static const yytype_int16 yytable[] = 0, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, - 517, 518, 519, 520, 528, 0, 0, 0, 0, 0, + 517, 518, 519, 520, 528, 0, 554, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 2208, 0, 0, 118, 119, 120, 121, 122, 123, 124, - 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, - 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, - 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, - 152, 153, 154, 155, 156, 0, 157, 158, 159, 160, - 161, 0, 0, 0, 163, 164, 165, 166, 167, 168, - 0, 170, 171, 172, 0, 173, 174, 175, 176, 177, - 178, 0, 0, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, - 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, - 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, - 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, - 0, 235, 0, 0, 0, 238, 239, 529, 0, 242, - 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, - 250, 251, 252, 253, 254, 0, 256, 257, 258, 259, - 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, - 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, - 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, - 286, 287, 288, 0, 0, 289, 0, 291, 0, 0, - 293, 294, 295, 296, 297, 298, 299, 300, 530, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 0, 324, 325, 326, 327, 328, 0, 329, 330, 0, - 332, 0, 333, 334, 335, 336, 337, 338, 0, 339, - 340, 0, 0, 341, 342, 343, 0, 0, 344, 345, - 346, 0, 348, 0, 350, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, - 362, 363, 364, 0, 366, 367, 368, 369, 370, 371, - 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, - 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, - 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, - 399, 400, 0, 401, 402, 0, 404, 405, 406, 407, - 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, - 426, 427, 428, 429, 0, 0, 431, 432, 433, 434, - 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, - 444, 445, 446, 531, 448, 449, 0, 0, 450, 451, - 0, 452, 0, 454, 455, 456, 457, 458, 0, 459, - 460, 461, 0, 0, 462, 463, 464, 465, 466, 0, - 467, 468, 469, 470, 471, 472, 473, 474, 0, 0, - 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, - 483, 484, 485, 486, 487, 488, 489, 0, 490, 0, - 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, - 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, - 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, - 518, 519, 520, 0, 2972, 1364, 821, 0, 0, 2076, - 1060, 0, 0, 0, 0, 0, 2077, 2078, 0, 3163, - 2079, 2080, 2081, 118, 119, 120, 121, 122, 123, 124, - 125, 561, 126, 127, 128, 562, 563, 564, 2973, 566, - 567, 568, 569, 2974, 130, 131, 571, 132, 133, 134, - 2975, 136, 137, 138, 0, 1506, 2976, 1508, 1509, 578, - 144, 145, 146, 147, 148, 149, 579, 580, 150, 151, - 152, 153, 1510, 1511, 156, 583, 157, 158, 159, 160, - 0, 585, 2977, 587, 2978, 164, 165, 166, 167, 168, - 2979, 170, 171, 172, 590, 173, 174, 175, 176, 177, - 178, 591, 2980, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 1516, 191, 192, 1517, 194, 596, 195, - 597, 196, 197, 198, 199, 200, 201, 598, 599, 202, - 203, 204, 205, 600, 601, 206, 207, 1073, 209, 210, - 602, 211, 212, 213, 603, 214, 215, 216, 604, 217, - 218, 219, 220, 0, 222, 223, 224, 225, 226, 227, - 0, 607, 229, 608, 230, 231, 1518, 233, 610, 234, - 611, 235, 2981, 613, 2982, 238, 239, 2983, 2984, 242, - 617, 243, 618, 0, 0, 246, 247, 621, 248, 249, - 250, 251, 252, 253, 254, 2985, 256, 257, 258, 259, - 623, 260, 261, 262, 263, 264, 265, 266, 624, 267, - 2986, 0, 270, 271, 272, 273, 274, 1524, 1525, 629, - 1526, 631, 278, 2987, 2988, 281, 2989, 283, 284, 285, - 286, 287, 288, 635, 636, 289, 2990, 291, 2991, 639, - 293, 294, 295, 296, 297, 298, 299, 300, 2992, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 1533, - 2993, 1535, 325, 326, 327, 2994, 645, 329, 330, 2995, - 332, 647, 0, 334, 1537, 336, 337, 338, 650, 339, - 340, 651, 652, 2996, 342, 343, 653, 654, 344, 345, - 0, 2997, 348, 2998, 0, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, 361, 659, 660, 661, 662, - 362, 363, 0, 2999, 366, 367, 0, 369, 370, 371, - 666, 372, 373, 374, 375, 376, 377, 667, 378, 379, - 380, 381, 382, 1541, 384, 385, 386, 387, 669, 388, - 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, - 399, 400, 670, 401, 402, 3000, 404, 405, 406, 1543, - 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 673, 3001, 421, 422, 423, 424, 425, - 426, 3002, 428, 429, 676, 3003, 431, 432, 1547, 434, - 679, 435, 436, 437, 438, 439, 440, 441, 442, 443, - 444, 445, 446, 3004, 448, 0, 682, 683, 450, 451, - 684, 452, 3005, 454, 455, 456, 457, 458, 686, 459, - 1550, 1551, 689, 690, 462, 463, 0, 465, 0, 693, - 467, 468, 3006, 470, 471, 472, 473, 474, 3007, 696, - 475, 476, 477, 697, 478, 479, 480, 481, 698, 482, - 483, 484, 485, 486, 0, 1554, 489, 701, 490, 3008, - 492, 493, 494, 495, 496, 497, 498, 703, 704, 499, - 705, 706, 500, 501, 502, 503, 504, 505, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 517, - 518, 519, 520, 0, 528, 0, 2082, 2083, 2084, 2076, - 3009, 3010, 2087, 2088, 2089, 2090, 2077, 2078, 0, 0, - 2079, 2080, 2081, 118, 119, 120, 121, 122, 123, 124, + 2495, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, @@ -8641,221 +8334,158 @@ static const yytype_int16 yytable[] = 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, - 518, 519, 520, 0, 0, 0, 2082, 2083, 2084, 0, - 2085, 2086, 2087, 2088, 2089, 2090, 1639, 0, 0, 1640, - 0, 0, 0, 1641, 1642, 1643, 1644, 1645, 1646, 1647, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1648, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1650, 1639, 0, 0, 1640, 0, - 0, 1651, 1641, 1642, 1643, 1644, 1645, 1646, 1647, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1648, 0, 0, 0, 0, 1652, 0, - 0, 0, 0, 1650, 1639, 0, 0, 1640, 0, 0, - 1651, 1641, 1642, 1643, 1644, 1645, 1646, 1647, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1648, 0, 0, 0, 0, 1652, 0, 0, - 0, 0, 1650, 0, 0, 0, 0, 0, 0, 1651, - 0, 0, 1639, 0, 0, 1640, 0, 0, 0, 1641, - 1642, 1643, 1644, 1645, 1646, 1647, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1652, 0, 0, 0, - 1648, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1650, 1639, 0, 0, 1640, 1653, 0, 1651, 1641, 1642, - 1643, 1644, 1645, 1646, 1647, 0, 0, 0, 0, 0, - 0, 0, 1654, 0, 0, 0, 0, 1655, 0, 1648, - 0, 0, 0, 0, 1652, 0, 0, 0, 0, 1650, - 0, 0, 0, 0, 1653, 0, 1651, 0, 0, 0, - 1656, 1657, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1654, 0, 0, 0, 1658, 1655, 0, 0, 0, - 0, 0, 0, 1652, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1653, 0, 0, 0, 0, 0, 1656, - 1657, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1654, 0, 0, 1659, 1658, 1655, 1660, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1661, 0, 0, 1662, 0, 0, 0, 0, 1656, 1657, - 0, 1653, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1659, 1658, 0, 1660, 0, 0, 1654, 0, - 0, 0, 0, 1655, 0, 0, 0, 0, 0, 1661, - 0, 0, 1662, 0, 0, 0, 0, 0, 0, 0, - 1653, 0, 0, 0, 0, 0, 1656, 1657, 0, 0, - 0, 1659, 0, 0, 1660, 0, 0, 1654, 0, 0, - 0, 1658, 1655, 0, 0, 0, 0, 0, 1661, 0, - 0, 1662, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1656, 1657, 0, 0, 0, - 0, 0, 1663, 0, 0, 0, 0, 0, 0, 1659, - 1658, 0, 1660, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1661, 0, 0, 1662, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1663, 0, 0, 0, 0, 0, 0, 1659, 0, - 0, 1660, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1661, 0, 0, 1662, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1663, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1664, 0, 0, 1665, 1666, 1667, 0, 1668, 1669, 1670, - 1671, 1672, 1673, 0, 0, 0, 0, 2918, 1663, 0, - 0, 0, 0, 0, 1639, 0, 0, 1640, 0, 0, - 0, 1641, 1642, 1643, 1644, 1645, 1646, 1647, 0, 1664, - 0, 0, 1665, 1666, 1667, 0, 1668, 1669, 1670, 1671, - 1672, 1673, 1648, 0, 0, 0, 3155, 1663, 0, 0, - 0, 0, 1650, 0, 0, 0, 0, 0, 0, 1651, - 0, 0, 0, 0, 0, 0, 0, 0, 1664, 0, - 0, 1665, 1666, 1667, 0, 1668, 1669, 1670, 1671, 1672, - 1673, 0, 0, 0, 0, 3162, 1652, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1639, 0, 0, 1640, 0, 0, 0, 1641, 1642, - 1643, 1644, 1645, 1646, 1647, 0, 1664, 0, 0, 1665, - 1666, 1667, 0, 1668, 1669, 1670, 1671, 1672, 1673, 1648, - 0, 0, 0, 3324, 0, 0, 0, 0, 0, 1650, - 1639, 0, 0, 1640, 0, 0, 1651, 1641, 1642, 1643, - 1644, 1645, 1646, 1647, 0, 1664, 0, 0, 1665, 1666, - 1667, 0, 1668, 1669, 1670, 1671, 1672, 1673, 1648, 0, - 0, 0, 3346, 1652, 0, 0, 0, 0, 1650, 1639, - 0, 0, 1640, 1653, 0, 1651, 1641, 1642, 1643, 1644, - 1645, 1646, 1647, 0, 0, 0, 0, 0, 0, 0, - 1654, 0, 0, 0, 0, 1655, 0, 1648, 0, 0, - 0, 0, 1652, 0, 0, 0, 0, 1650, 0, 0, - 0, 0, 0, 0, 1651, 0, 0, 0, 1656, 1657, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1658, 0, 0, 0, 0, 0, 0, - 0, 1652, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1639, 0, 0, 1640, - 1653, 0, 0, 1641, 1642, 1643, 1644, 1645, 1646, 1647, - 0, 1659, 0, 0, 1660, 0, 0, 1654, 0, 0, - 0, 0, 1655, 0, 1648, 0, 0, 0, 1661, 0, - 0, 1662, 0, 0, 1650, 0, 0, 0, 0, 1653, - 0, 1651, 0, 0, 0, 1656, 1657, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1654, 0, 0, 0, - 1658, 1655, 0, 0, 0, 0, 0, 0, 1652, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1653, 0, - 0, 0, 0, 0, 1656, 1657, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1654, 0, 0, 1659, 1658, - 1655, 1660, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1661, 0, 0, 1662, 0, - 0, 0, 0, 1656, 1657, 0, 0, 0, 0, 0, - 1663, 0, 0, 0, 0, 0, 0, 1659, 1658, 0, - 1660, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1661, 0, 0, 1662, 0, 0, - 0, 0, 0, 0, 0, 1653, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1659, 0, 0, 1660, - 0, 0, 1654, 0, 0, 0, 0, 1655, 0, 0, - 0, 0, 0, 1661, 0, 0, 1662, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1656, 1657, 0, 0, 0, 0, 0, 1663, 0, 0, - 0, 0, 0, 0, 0, 1658, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1664, 0, - 0, 1665, 1666, 1667, 0, 1668, 1669, 1670, 1671, 1672, - 1673, 0, 0, 0, 0, 3446, 1663, 0, 0, 0, - 0, 0, 0, 1659, 0, 0, 1660, 0, 0, 0, - 0, 0, 0, 0, 1639, 0, 0, 1640, 0, 0, - 1661, 1641, 1642, 1662, 0, 1645, 1646, 1647, 0, 0, - 0, 0, 0, 1639, 0, 1663, 1640, 0, 0, 0, - 1641, 1642, 1643, 1644, 1645, 1646, 1647, 0, 0, 0, - 0, 0, 1650, 0, 0, 0, 0, 0, 0, 1651, - 0, 1648, 0, 0, 0, 1664, 0, 0, 1665, 1666, - 1667, 1650, 1668, 1669, 1670, 1671, 1672, 1673, 1651, 0, - 0, 0, 3502, 0, 0, 0, 1652, 0, 0, 0, - 1639, 0, 0, 1640, 0, 0, 0, 1641, 1642, 1643, - 1644, 1645, 1646, 1647, 1664, 1652, 0, 1665, 1666, 1667, - 0, 1668, 1669, 1670, 1671, 1672, 1673, 0, 1648, 0, - 0, 3524, 1663, 0, 0, 0, 0, 0, 1650, 0, - 0, 0, 0, 0, 0, 1651, 0, 0, 0, 0, - 0, 0, 0, 1664, 0, 0, 1665, 1666, 1667, 0, - 1668, 1669, 1670, 1671, 1672, 1673, 0, 0, 1827, 0, - 0, 0, 1652, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1653, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1654, 0, 1653, 0, 0, 1655, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1654, - 0, 0, 0, 0, 1655, 0, 0, 0, -2102, -2102, - 1664, 0, 0, 1665, 1666, 1667, 0, 1668, 1669, 1670, - 1671, 1672, 1673, 1658, 0, 2872, 0, 1656, 1657, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1653, - 0, 0, 1658, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1654, 0, 0, 0, - 0, 1655, 0, 0, -2102, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1661, 0, - 1659, 0, 0, 1660, 1656, 1657, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1661, 0, 1658, - 1662, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1659, 0, 0, - 1660, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1661, 0, 0, 1662, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1663, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1663, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1663, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1664, 0, - 0, 1665, 1666, 1667, 0, 1668, 1669, 1670, 1671, 1672, - 1673, 0, 0, 0, 0, 0, 0, 1664, 0, 0, - 1665, 1666, 1667, 0, 1668, 1669, 1670, 1671, 1672, 1673, - 0, 0, 3314, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 560, 0, 0, 1664, 0, 0, 1665, 1666, 1667, - 0, 1668, 1669, 1670, 1671, 1672, 1673, 0, 0, 3486, - 118, 119, 120, 121, 122, 123, 124, 125, 561, 126, - 127, 128, 562, 563, 564, 565, 566, 567, 568, 569, - 570, 130, 131, 571, 132, 133, 134, 572, 136, 137, - 138, 573, 574, 575, 576, 577, 578, 144, 145, 146, - 147, 148, 149, 579, 580, 150, 151, 152, 153, 581, - 582, 156, 583, 157, 158, 159, 160, 584, 585, 586, - 587, 588, 164, 165, 166, 167, 168, 589, 170, 171, - 172, 590, 173, 174, 175, 176, 177, 178, 591, 592, + 518, 519, 520, 528, 0, 554, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 2636, + 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, + 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, + 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, + 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, + 153, 154, 155, 156, 0, 157, 158, 159, 160, 161, + 0, 0, 0, 163, 164, 165, 166, 167, 168, 0, + 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, + 0, 0, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, + 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, + 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, + 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, + 235, 0, 0, 0, 238, 239, 529, 0, 242, 0, + 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, + 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, + 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, + 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, + 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, + 287, 288, 0, 0, 289, 0, 291, 0, 0, 293, + 294, 295, 296, 297, 298, 299, 300, 530, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 322, 0, + 324, 325, 326, 327, 328, 0, 329, 330, 0, 332, + 0, 333, 334, 335, 336, 337, 338, 0, 339, 340, + 0, 0, 341, 342, 343, 0, 0, 344, 345, 346, + 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, + 363, 364, 0, 366, 367, 368, 369, 370, 371, 0, + 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, + 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, + 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, + 400, 0, 401, 402, 0, 404, 405, 406, 407, 408, + 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, + 419, 420, 0, 0, 421, 422, 423, 424, 425, 426, + 427, 428, 429, 0, 0, 431, 432, 433, 434, 0, + 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, + 445, 446, 531, 448, 449, 0, 0, 450, 451, 0, + 452, 0, 454, 455, 456, 457, 458, 0, 459, 460, + 461, 0, 0, 462, 463, 464, 465, 466, 0, 467, + 468, 469, 470, 471, 472, 473, 474, 0, 0, 475, + 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, + 484, 485, 486, 487, 488, 489, 0, 490, 0, 492, + 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, + 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, + 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, + 519, 520, 528, 0, 554, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 2847, 0, + 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, + 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, + 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, + 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, + 154, 155, 156, 0, 157, 158, 159, 160, 161, 0, + 0, 0, 163, 164, 165, 166, 167, 168, 0, 170, + 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, + 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, + 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, + 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, + 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 0, + 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, + 0, 0, 0, 238, 239, 529, 0, 242, 0, 243, + 0, 244, 245, 246, 247, 0, 248, 249, 250, 251, + 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, + 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, + 278, 0, 0, 281, 0, 283, 284, 285, 286, 287, + 288, 0, 0, 289, 0, 291, 0, 0, 293, 294, + 295, 296, 297, 298, 299, 300, 530, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 0, 324, + 325, 326, 327, 328, 0, 329, 330, 0, 332, 0, + 333, 334, 335, 336, 337, 338, 0, 339, 340, 0, + 0, 341, 342, 343, 0, 0, 344, 345, 346, 0, + 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, + 364, 0, 366, 367, 368, 369, 370, 371, 0, 372, + 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, + 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 0, 401, 402, 0, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 0, 0, 431, 432, 433, 434, 0, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, 531, 448, 449, 0, 0, 450, 451, 0, 452, + 0, 454, 455, 456, 457, 458, 0, 459, 460, 461, + 0, 0, 462, 463, 464, 465, 466, 0, 467, 468, + 469, 470, 471, 472, 473, 474, 0, 0, 475, 476, + 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, + 485, 486, 487, 488, 489, 0, 490, 0, 492, 493, + 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, + 520, 528, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3302, 0, 0, + 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, + 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, + 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, + 147, 148, 149, 0, 0, 150, 151, 152, 153, 154, + 155, 156, 0, 157, 158, 159, 160, 161, 0, 0, + 0, 163, 164, 165, 166, 167, 168, 0, 170, 171, + 172, 0, 173, 174, 175, 176, 177, 178, 0, 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 594, 191, 192, 595, 194, 596, 195, 597, 196, 197, - 198, 199, 200, 201, 598, 599, 202, 203, 204, 205, - 600, 601, 206, 207, 208, 209, 210, 602, 211, 212, - 213, 603, 214, 215, 216, 604, 217, 218, 219, 220, - 605, 222, 223, 224, 225, 226, 227, 606, 607, 229, - 608, 230, 231, 609, 233, 610, 234, 611, 235, 612, - 613, 614, 238, 239, 615, 616, 242, 617, 243, 618, - 619, 620, 246, 247, 621, 248, 249, 250, 251, 252, - 253, 254, 622, 256, 257, 258, 259, 623, 260, 261, - 262, 263, 264, 265, 266, 624, 267, 625, 626, 270, - 271, 272, 273, 274, 627, 628, 629, 630, 631, 278, - 632, 633, 281, 634, 283, 284, 285, 286, 287, 288, - 635, 636, 289, 637, 291, 638, 639, 293, 294, 295, - 296, 297, 298, 299, 300, 640, 302, 303, 304, 305, + 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, + 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, + 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, + 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 0, 229, + 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, + 0, 0, 238, 239, 529, 0, 242, 0, 243, 0, + 244, 245, 246, 247, 0, 248, 249, 250, 251, 252, + 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, + 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, + 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, + 0, 0, 281, 0, 283, 284, 285, 286, 287, 288, + 0, 0, 289, 0, 291, 0, 0, 293, 294, 295, + 296, 297, 298, 299, 300, 530, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 641, 642, 643, 325, - 326, 327, 644, 645, 329, 330, 646, 332, 647, 648, - 334, 649, 336, 337, 338, 650, 339, 340, 651, 652, - 341, 342, 343, 653, 654, 344, 345, 655, 656, 348, - 657, 658, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, 361, 659, 660, 661, 662, 362, 363, 663, - 664, 366, 367, 665, 369, 370, 371, 666, 372, 373, - 374, 375, 376, 377, 667, 378, 379, 380, 381, 382, - 668, 384, 385, 386, 387, 669, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 397, 398, 399, 400, 670, - 401, 402, 671, 404, 405, 406, 672, 408, 409, 410, + 316, 317, 318, 319, 320, 321, 322, 0, 324, 325, + 326, 327, 328, 0, 329, 330, 0, 332, 0, 333, + 334, 335, 336, 337, 338, 0, 339, 340, 0, 0, + 341, 342, 343, 0, 0, 344, 345, 346, 0, 348, + 0, 350, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 360, 361, 0, 0, 0, 0, 362, 363, 364, + 0, 366, 367, 368, 369, 370, 371, 0, 372, 373, + 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, + 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, + 401, 402, 0, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 673, 674, 421, 422, 423, 424, 425, 426, 675, 428, - 429, 676, 677, 431, 432, 678, 434, 679, 435, 436, + 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, + 429, 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - 680, 448, 681, 682, 683, 450, 451, 684, 452, 685, - 454, 455, 456, 457, 458, 686, 459, 687, 688, 689, - 690, 462, 463, 691, 465, 692, 693, 467, 468, 694, - 470, 471, 472, 473, 474, 695, 696, 475, 476, 477, - 697, 478, 479, 480, 481, 698, 482, 483, 484, 485, - 486, 699, 700, 489, 701, 490, 702, 492, 493, 494, - 495, 496, 497, 498, 703, 704, 499, 705, 706, 500, - 501, 502, 503, 504, 505, 707, 708, 709, 710, 711, - 712, 713, 714, 715, 716, 717, 517, 518, 519, 520, - 528, 0, 0, 0, 0, 0, 0, 0, 0, 2113, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, + 531, 448, 449, 0, 0, 450, 451, 0, 452, 0, + 454, 455, 456, 457, 458, 0, 459, 460, 461, 0, + 0, 462, 463, 464, 465, 466, 0, 467, 468, 469, + 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, + 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, + 486, 487, 488, 489, 0, 490, 0, 492, 493, 494, + 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, + 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, + 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, + 528, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 2210, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, @@ -8903,349 +8533,272 @@ static const yytype_int16 yytable[] = 487, 488, 489, 0, 490, 0, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, - 512, 513, 514, 515, 516, 517, 518, 519, 520, 528, - 0, 0, 0, 0, 0, 0, 0, 0, 2765, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, - 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, - 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, - 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, - 149, 0, 0, 150, 151, 152, 153, 154, 155, 156, - 0, 157, 158, 159, 160, 161, 0, 0, 0, 163, - 164, 165, 166, 167, 168, 0, 170, 171, 172, 0, - 173, 174, 175, 176, 177, 178, 0, 0, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, - 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, - 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, - 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, - 214, 215, 216, 0, 217, 218, 219, 220, 221, 222, - 223, 224, 225, 226, 227, 228, 0, 229, 0, 230, - 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, - 238, 239, 529, 0, 242, 0, 243, 0, 244, 245, - 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, - 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, - 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, - 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, - 281, 0, 283, 284, 285, 286, 287, 288, 0, 0, - 289, 0, 291, 0, 0, 293, 294, 295, 296, 297, - 298, 299, 300, 530, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, 321, 322, 0, 324, 325, 326, 327, - 328, 0, 329, 330, 0, 332, 0, 333, 334, 335, - 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, - 343, 0, 0, 344, 345, 346, 0, 348, 0, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - 361, 0, 0, 0, 0, 362, 363, 364, 0, 366, - 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, - 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, - 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, - 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, - 0, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, - 421, 422, 423, 424, 425, 426, 427, 428, 429, 0, - 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 445, 446, 531, 448, - 449, 0, 0, 450, 451, 0, 452, 0, 454, 455, - 456, 457, 458, 0, 459, 460, 461, 0, 0, 462, - 463, 464, 465, 466, 0, 467, 468, 469, 470, 471, - 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, - 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, - 488, 489, 0, 490, 0, 492, 493, 494, 495, 496, - 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 516, 517, 518, 519, 520, 974, 1364, - 821, 0, 0, 0, 1060, 0, 0, 2768, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, - 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, - 0, 0, 565, 0, 0, 0, 0, 570, 130, 131, - 0, 132, 133, 134, 572, 136, 137, 138, 573, 574, - 575, 576, 577, 0, 144, 145, 146, 147, 148, 149, - 0, 0, 150, 151, 152, 153, 581, 582, 156, 0, - 157, 158, 159, 160, 584, 0, 586, 0, 588, 164, - 165, 166, 167, 168, 589, 170, 171, 172, 0, 173, - 174, 175, 176, 177, 178, 0, 592, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 594, 191, 192, - 595, 194, 0, 195, 0, 196, 197, 198, 199, 200, - 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, - 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, - 215, 216, 0, 217, 218, 219, 220, 605, 222, 223, - 224, 225, 226, 227, 606, 1365, 229, 0, 230, 231, - 609, 233, 0, 234, 0, 235, 612, 0, 614, 238, - 239, 615, 616, 242, 0, 243, 0, 619, 620, 246, - 247, 0, 248, 249, 250, 251, 252, 253, 254, 622, - 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, - 265, 266, 0, 267, 625, 626, 270, 271, 272, 273, - 274, 627, 628, 0, 630, 0, 278, 632, 633, 281, - 634, 283, 284, 285, 286, 287, 288, 0, 0, 289, - 637, 291, 638, 0, 293, 294, 295, 296, 297, 298, - 299, 300, 640, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 641, 642, 643, 325, 326, 327, 644, - 0, 329, 330, 646, 332, 0, 648, 334, 649, 336, - 337, 338, 0, 339, 340, 1366, 0, 341, 342, 343, - 0, 0, 344, 345, 655, 656, 348, 657, 658, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, - 0, 0, 0, 0, 362, 363, 663, 664, 366, 367, - 665, 369, 370, 371, 0, 372, 373, 374, 375, 376, - 377, 0, 378, 379, 380, 381, 382, 668, 384, 385, - 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 397, 398, 399, 400, 0, 401, 402, 671, - 404, 405, 406, 672, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 417, 418, 419, 420, 0, 674, 421, - 422, 423, 424, 425, 426, 675, 428, 429, 0, 677, - 431, 432, 678, 434, 0, 435, 436, 437, 438, 439, - 440, 441, 442, 443, 444, 445, 446, 680, 448, 681, - 0, 0, 450, 451, 0, 452, 685, 454, 455, 456, - 457, 458, 0, 459, 687, 688, 0, 0, 462, 463, - 691, 465, 692, 1367, 467, 468, 694, 470, 471, 472, - 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, - 480, 481, 0, 482, 483, 484, 485, 486, 699, 700, - 489, 0, 490, 702, 492, 493, 494, 495, 496, 497, - 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, - 504, 505, 707, 708, 709, 710, 711, 712, 713, 714, - 715, 716, 717, 517, 518, 519, 520, 0, 0, 1639, - 0, 0, 1640, 0, 1368, 1369, 1641, 1642, 1643, 1644, - 1645, 1646, 1647, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1648, 0, 0, - 0, 0, 2214, 0, 0, 0, 0, 1650, 1639, 0, - 0, 1640, 0, 0, 1651, 1641, 1642, 1643, 1644, 1645, - 1646, 1647, 0, 0, 0, 0, 1639, 0, 0, 1640, - 0, 0, 0, 1641, 1642, 0, 1648, 1645, 1646, 1647, - 0, 1652, 0, 0, 0, 0, 1650, 1639, 0, 0, - 1640, 0, 0, 1651, 1641, 1642, 1643, 1644, 1645, 1646, - 1647, 0, 0, 0, 1650, 0, 0, 0, 0, 0, - 0, 1651, 0, 0, 0, 1648, 0, 0, 0, 0, - 1652, 0, 0, 0, 0, 1650, 0, 2215, 0, 0, - 0, 0, 1651, 0, 1639, 0, 0, 1640, 1652, 0, - 0, 1641, 1642, 1643, 1644, 1645, 1646, 1647, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1652, - 0, 0, 1648, 0, 0, 0, 1927, 0, 0, 0, - 0, 0, 1650, 0, 0, 0, 0, 0, 1653, 1651, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1654, 0, 0, 0, 0, - 1655, 0, 0, 0, 0, 0, 1652, 1963, 0, 0, - 0, 0, 1964, 0, 0, 0, 0, 1653, 0, 0, - 0, 0, 0, 1656, 1657, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1654, 1653, 0, 0, 1658, 1655, - 0, 0, 0, 0, 0, 3592, 0, 0, 0, 0, - 0, 0, 1654, 0, 0, 0, 1653, 1655, 0, 0, - 0, 0, 1656, 1657, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1654, 0, 0, 1659, 1658, 1655, 1660, - 1656, 1657, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1661, 0, 1658, 1662, 0, 0, 0, - 0, 1656, 1657, 1653, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1659, 1658, 0, 1660, 0, - 1654, 0, 0, 0, 0, 1655, 0, 0, 0, 0, - 0, 0, 1661, 1659, 0, 1662, 1660, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1656, 1657, - 1661, 0, 0, 0, 1659, 0, 0, 1660, 0, 0, - 0, 0, 0, 1658, 0, 0, 0, 0, 0, 0, - 0, 1661, 0, 0, 1662, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1663, 0, 0, 0, 0, - 0, 1659, 0, 3593, 1660, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1661, 0, - 0, 1662, 0, 0, 0, 0, 0, 0, 0, 1639, - 0, 0, 1640, 0, 1663, 0, 1641, 1642, 1643, 1644, - 1645, 1646, 1647, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1663, 0, 0, 0, 0, 1648, 2218, 0, - 0, 0, 0, 0, 0, 0, 0, 1650, 0, 0, - 0, 0, 0, 1663, 1651, 0, 0, 0, 0, 0, + 512, 513, 514, 515, 516, 517, 518, 519, 520, 0, + 2973, 1364, 821, 0, 0, 2078, 1060, 0, 0, 0, + 0, 0, 2079, 2080, 0, 3164, 2081, 2082, 2083, 118, + 119, 120, 121, 122, 123, 124, 125, 561, 126, 127, + 128, 562, 563, 564, 2974, 566, 567, 568, 569, 2975, + 130, 131, 571, 132, 133, 134, 2976, 136, 137, 138, + 0, 1506, 2977, 1508, 1509, 578, 144, 145, 146, 147, + 148, 149, 579, 580, 150, 151, 152, 153, 1510, 1511, + 156, 583, 157, 158, 159, 160, 0, 585, 2978, 587, + 2979, 164, 165, 166, 167, 168, 2980, 170, 171, 172, + 590, 173, 174, 175, 176, 177, 178, 591, 2981, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 1516, + 191, 192, 1517, 194, 596, 195, 597, 196, 197, 198, + 199, 200, 201, 598, 599, 202, 203, 204, 205, 600, + 601, 206, 207, 1073, 209, 210, 602, 211, 212, 213, + 603, 214, 215, 216, 604, 217, 218, 219, 220, 0, + 222, 223, 224, 225, 226, 227, 0, 607, 229, 608, + 230, 231, 1518, 233, 610, 234, 611, 235, 2982, 613, + 2983, 238, 239, 2984, 2985, 242, 617, 243, 618, 0, + 0, 246, 247, 621, 248, 249, 250, 251, 252, 253, + 254, 2986, 256, 257, 258, 259, 623, 260, 261, 262, + 263, 264, 265, 266, 624, 267, 2987, 0, 270, 271, + 272, 273, 274, 1524, 1525, 629, 1526, 631, 278, 2988, + 2989, 281, 2990, 283, 284, 285, 286, 287, 288, 635, + 636, 289, 2991, 291, 2992, 639, 293, 294, 295, 296, + 297, 298, 299, 300, 2993, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, + 317, 318, 319, 320, 321, 1533, 2994, 1535, 325, 326, + 327, 2995, 645, 329, 330, 2996, 332, 647, 0, 334, + 1537, 336, 337, 338, 650, 339, 340, 651, 652, 2997, + 342, 343, 653, 654, 344, 345, 0, 2998, 348, 2999, + 0, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, 361, 659, 660, 661, 662, 362, 363, 0, 3000, + 366, 367, 0, 369, 370, 371, 666, 372, 373, 374, + 375, 376, 377, 667, 378, 379, 380, 381, 382, 1541, + 384, 385, 386, 387, 669, 388, 389, 390, 391, 392, + 393, 394, 395, 396, 397, 398, 399, 400, 670, 401, + 402, 3001, 404, 405, 406, 1543, 408, 409, 410, 411, + 412, 413, 414, 415, 416, 417, 418, 419, 420, 673, + 3002, 421, 422, 423, 424, 425, 426, 3003, 428, 429, + 676, 3004, 431, 432, 1547, 434, 679, 435, 436, 437, + 438, 439, 440, 441, 442, 443, 444, 445, 446, 3005, + 448, 0, 682, 683, 450, 451, 684, 452, 3006, 454, + 455, 456, 457, 458, 686, 459, 1550, 1551, 689, 690, + 462, 463, 0, 465, 0, 693, 467, 468, 3007, 470, + 471, 472, 473, 474, 3008, 696, 475, 476, 477, 697, + 478, 479, 480, 481, 698, 482, 483, 484, 485, 486, + 0, 1554, 489, 701, 490, 3009, 492, 493, 494, 495, + 496, 497, 498, 703, 704, 499, 705, 706, 500, 501, + 502, 503, 504, 505, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 517, 518, 519, 520, 0, + 528, 0, 2084, 2085, 2086, 2078, 3010, 3011, 2089, 2090, + 2091, 2092, 2079, 2080, 0, 0, 2081, 2082, 2083, 118, + 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, + 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, + 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, + 148, 149, 0, 0, 150, 151, 152, 153, 154, 155, + 156, 0, 157, 158, 159, 160, 161, 0, 0, 0, + 163, 164, 165, 166, 167, 168, 0, 170, 171, 172, + 0, 173, 174, 175, 176, 177, 178, 0, 0, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, + 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, + 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, + 0, 214, 215, 216, 0, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 0, 229, 0, + 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, + 0, 238, 239, 529, 0, 242, 0, 243, 0, 244, + 245, 246, 247, 0, 248, 249, 250, 251, 252, 253, + 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, + 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, + 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, + 0, 281, 0, 283, 284, 285, 286, 287, 288, 0, + 0, 289, 0, 291, 0, 0, 293, 294, 295, 296, + 297, 298, 299, 300, 530, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, + 317, 318, 319, 320, 321, 322, 0, 324, 325, 326, + 327, 328, 0, 329, 330, 0, 332, 0, 333, 334, + 335, 336, 337, 338, 0, 339, 340, 0, 0, 341, + 342, 343, 0, 0, 344, 345, 346, 0, 348, 0, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, 361, 0, 0, 0, 0, 362, 363, 364, 0, + 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, + 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, + 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, + 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, + 402, 0, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, + 0, 421, 422, 423, 424, 425, 426, 427, 428, 429, + 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, + 438, 439, 440, 441, 442, 443, 444, 445, 446, 531, + 448, 449, 0, 0, 450, 451, 0, 452, 0, 454, + 455, 456, 457, 458, 0, 459, 460, 461, 0, 0, + 462, 463, 464, 465, 466, 0, 467, 468, 469, 470, + 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, + 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, + 487, 488, 489, 0, 490, 0, 492, 493, 494, 495, + 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, + 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, + 512, 513, 514, 515, 516, 517, 518, 519, 520, 0, + 0, 0, 2084, 2085, 2086, 0, 2087, 2088, 2089, 2090, + 2091, 2092, 1639, 0, 0, 1640, 0, 0, 0, 1641, + 1642, 1643, 1644, 1645, 1646, 1647, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1648, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1650, 1639, 0, 0, 1640, 0, 0, 1651, 1641, 1642, + 1643, 1644, 1645, 1646, 1647, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1648, + 0, 0, 0, 0, 1652, 0, 0, 0, 0, 1650, + 1639, 0, 0, 1640, 0, 0, 1651, 1641, 1642, 1643, + 1644, 1645, 1646, 1647, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1648, 0, + 0, 0, 0, 1652, 0, 0, 0, 0, 1650, 0, + 0, 0, 0, 0, 0, 1651, 0, 0, 1639, 0, + 0, 1640, 0, 0, 0, 1641, 1642, 1643, 1644, 1645, + 1646, 1647, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1652, 0, 0, 0, 1648, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1650, 1639, 0, 0, + 1640, 1653, 0, 1651, 1641, 1642, 1643, 1644, 1645, 1646, + 1647, 0, 0, 0, 0, 0, 0, 0, 1654, 0, + 0, 0, 0, 1655, 0, 1648, 0, 0, 0, 0, + 1652, 0, 0, 0, 0, 1650, 0, 0, 0, 0, + 1653, 0, 1651, 0, 0, 0, 1656, 1657, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1654, 0, 0, + 0, 1658, 1655, 0, 0, 0, 0, 0, 0, 1652, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1653, + 0, 0, 0, 0, 0, 1656, 1657, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1654, 0, 0, 1659, + 1658, 1655, 1660, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1661, 0, 0, 1662, + 0, 0, 0, 0, 1656, 1657, 0, 1653, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1659, 1658, + 0, 1660, 0, 0, 1654, 0, 0, 0, 0, 1655, + 0, 0, 0, 0, 0, 1661, 0, 0, 1662, 0, + 0, 0, 0, 0, 0, 0, 1653, 0, 0, 0, + 0, 0, 1656, 1657, 0, 0, 0, 1659, 0, 0, + 1660, 0, 0, 1654, 0, 0, 0, 1658, 1655, 0, + 0, 0, 0, 0, 1661, 0, 0, 1662, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1652, 0, 1664, 0, 0, 1665, 1666, 1667, 0, - 1668, 1669, 1670, 1671, 1672, 1673, 0, 0, 0, 0, - 1663, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1656, 1657, 0, 0, 0, 0, 0, 1663, 0, + 0, 0, 0, 0, 0, 1659, 1658, 0, 1660, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1664, 0, 0, 1665, 1666, 1667, 0, 1668, - 1669, 1670, 1671, 1672, 1673, 0, 0, 0, 0, 0, - 1664, 0, 0, 1665, 1666, 1667, 0, 1668, 1669, 1670, - 1671, 1672, 1673, 0, 0, 0, 0, 0, 0, 0, - 0, 1664, 0, 0, 1665, 1666, 1667, 0, 1668, 1669, - 1670, 1671, 1672, 1673, 0, 0, 0, 0, 1653, 0, + 0, 0, 1661, 0, 0, 1662, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1663, 0, 0, + 0, 0, 0, 0, 1659, 0, 0, 1660, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1639, 1654, 0, 1640, 0, 0, - 1655, 1641, 1642, 1643, 1644, 1645, 1646, 1647, 1664, 0, - 0, 1665, 1666, 1667, 0, 1668, 1669, 1670, 1671, 1672, - 1673, 0, 1648, 1656, 1657, 0, 1969, 0, 0, 0, - 0, 0, 1650, 0, 0, 0, 0, 0, 1658, 1651, + 0, 1661, 0, 0, 1662, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1663, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1639, 0, 0, 1640, 0, 0, 1652, 1641, 1642, 1643, - 1644, 1645, 1646, 1647, 0, 0, 1659, 0, 0, 1660, - 0, 0, 0, 0, 0, 0, 0, 0, 1648, 0, - 0, 0, 0, 1661, 0, 0, 1662, 0, 1650, 0, + 0, 0, 0, 0, 0, 0, 1664, 0, 0, 1665, + 1666, 1667, 0, 1668, 1669, 1670, 1671, 1672, 1673, 0, + 0, 0, 0, 2919, 1663, 0, 0, 0, 0, 0, + 1639, 0, 0, 1640, 0, 0, 0, 1641, 1642, 1643, + 1644, 1645, 1646, 1647, 0, 1664, 0, 0, 1665, 1666, + 1667, 0, 1668, 1669, 1670, 1671, 1672, 1673, 1648, 0, + 0, 0, 3156, 1663, 0, 0, 0, 0, 1650, 0, 0, 0, 0, 0, 0, 1651, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1934, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1652, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1639, - 0, 0, 1640, 0, 0, 0, 1641, 1642, 1643, 1644, - 1645, 1646, 1647, 1653, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1648, 0, 0, - 1654, 1976, 0, 0, 0, 1655, 0, 1650, 0, 0, - 0, 0, 0, 0, 1651, 1663, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1656, 1657, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1652, 0, 1658, 1974, 0, 0, 0, 0, 1653, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1664, 0, 0, 1665, 1666, 1667, + 0, 1668, 1669, 1670, 1671, 1672, 1673, 0, 0, 0, + 0, 3163, 1652, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1639, 0, 0, + 1640, 0, 0, 0, 1641, 1642, 1643, 1644, 1645, 1646, + 1647, 0, 1664, 0, 0, 1665, 1666, 1667, 0, 1668, + 1669, 1670, 1671, 1672, 1673, 1648, 0, 0, 0, 3325, + 0, 0, 0, 0, 0, 1650, 1639, 0, 0, 1640, + 0, 0, 1651, 1641, 1642, 1643, 1644, 1645, 1646, 1647, + 0, 1664, 0, 0, 1665, 1666, 1667, 0, 1668, 1669, + 1670, 1671, 1672, 1673, 1648, 0, 0, 0, 3347, 1652, + 0, 0, 0, 0, 1650, 1639, 0, 0, 1640, 1653, + 0, 1651, 1641, 1642, 1643, 1644, 1645, 1646, 1647, 0, 0, 0, 0, 0, 0, 0, 1654, 0, 0, 0, - 0, 1655, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1659, 0, 0, 1660, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1656, 1657, 0, 0, 1661, 0, - 0, 1662, 0, 0, 0, 0, 0, 0, 0, 1658, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1664, 0, 0, 1665, 1666, 1667, 0, - 1668, 1669, 1670, 1671, 1672, 1673, 0, 0, 1653, 0, - 0, 0, 0, 0, 0, 0, 0, 1659, 0, 0, - 1660, 0, 0, 0, 0, 1654, 0, 0, 0, 0, - 1655, 0, 0, 0, 1661, 0, 0, 1662, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1639, 0, - 0, 1640, 0, 1656, 1657, 1641, 1642, 1643, 1644, 1645, - 1646, 1647, 0, 0, 0, 0, 0, 0, 1658, 0, - 1663, 0, 0, 0, 0, 0, 1648, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1650, 0, 0, 0, - 0, 0, 0, 1651, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1639, 1659, 0, 1640, 1660, - 0, 0, 1641, 1642, 1643, 1644, 1645, 1646, 1647, 0, - 1652, 0, 0, 1661, 0, 0, 1662, 0, 0, 0, - 0, 0, 0, 1648, 0, 0, 1663, 0, 0, 0, + 0, 1655, 0, 1648, 0, 0, 0, 0, 1652, 0, 0, 0, 0, 1650, 0, 0, 0, 0, 0, 0, - 1651, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1651, 0, 0, 0, 1656, 1657, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1658, + 0, 0, 0, 0, 0, 0, 0, 1652, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1652, 1664, 0, - 0, 1665, 1666, 1667, 0, 1668, 1669, 1670, 1671, 1672, - 1673, 0, 1639, 0, 0, 1640, 0, 0, 0, 1641, - 1642, 1643, 1644, 1645, 1646, 1647, 0, 2106, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1653, 0, 0, - 1648, 0, 0, 0, 2845, 1663, 0, 0, 0, 0, - 1650, 0, 0, 0, 1654, 0, 0, 1651, 0, 1655, - 0, 0, 0, 0, 1664, 0, 0, 1665, 1666, 1667, - 0, 1668, 1669, 1670, 1671, 1672, 1673, 0, 0, 0, - 0, 0, 1656, 1657, 1652, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1653, 0, 0, 1658, 0, 0, + 0, 0, 1639, 0, 0, 1640, 1653, 0, 0, 1641, + 1642, 1643, 1644, 1645, 1646, 1647, 0, 1659, 0, 0, + 1660, 0, 0, 1654, 0, 0, 0, 0, 1655, 0, + 1648, 0, 0, 0, 1661, 0, 0, 1662, 0, 0, + 1650, 0, 0, 0, 0, 1653, 0, 1651, 0, 0, + 0, 1656, 1657, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1654, 0, 0, 0, 1658, 1655, 0, 0, + 0, 0, 0, 0, 1652, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1653, 0, 0, 0, 0, 0, + 1656, 1657, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1654, 0, 0, 1659, 1658, 1655, 1660, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1654, 0, 0, 0, 0, 1655, 0, 0, 0, - 0, 1639, 0, 0, 1640, 0, 0, 0, 1641, 1642, - 1643, 1644, 1645, 1646, 1647, 1659, 0, 0, 1660, 1656, - 1657, 0, 0, 0, 0, 0, 0, 0, 0, 1648, - 0, 0, 1661, 1664, 1658, 1662, 1665, 1666, 1667, 1650, - 1668, 1669, 1670, 1671, 1672, 1673, 1651, 0, 0, 0, + 0, 1661, 0, 0, 1662, 0, 0, 0, 0, 1656, + 1657, 0, 0, 0, 0, 0, 1663, 0, 0, 0, + 0, 0, 0, 1659, 1658, 0, 1660, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1661, 0, 0, 1662, 0, 0, 0, 0, 0, 0, 0, 1653, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1659, 1652, 0, 1660, 0, 0, 1654, 0, + 0, 0, 1659, 0, 0, 1660, 0, 0, 1654, 0, 0, 0, 0, 1655, 0, 0, 0, 0, 0, 1661, 0, 0, 1662, 0, 0, 0, 0, 0, 0, 0, - 0, 1639, 0, 0, 1640, 0, 1656, 1657, 1641, 1642, - 1643, 1644, 1645, 1646, 1647, 0, 0, 0, 0, 0, - 0, 1658, 0, 0, 0, 0, 0, 0, 0, 1648, - 0, 0, 0, 0, 1663, 0, 0, 0, 0, 1650, - 0, 0, 0, 0, 0, 0, 1651, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1659, + 0, 0, 0, 0, 0, 0, 1656, 1657, 0, 0, + 0, 0, 0, 1663, 0, 0, 0, 0, 0, 0, + 0, 1658, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1664, 0, 0, 1665, 1666, 1667, + 0, 1668, 1669, 1670, 1671, 1672, 1673, 0, 0, 0, + 0, 3447, 1663, 0, 0, 0, 0, 0, 0, 1659, 0, 0, 1660, 0, 0, 0, 0, 0, 0, 0, - 1653, 0, 0, 1652, 0, 0, 1661, 0, 0, 1662, - 0, 0, 0, 0, 0, 0, 0, 1654, 0, 0, - 1639, 1663, 1655, 1640, 0, 0, 0, 1641, 1642, 1643, - 1644, 1645, 1646, 1647, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1656, 1657, 0, 1648, 0, - 0, 0, 0, 0, 2829, 0, 0, 0, 1650, 0, - 1658, 0, 0, 0, 0, 1651, 0, 0, 0, 0, - 0, 0, 1664, 0, 0, 1665, 1666, 1667, 0, 1668, - 1669, 1670, 1671, 1672, 1673, 0, 0, 0, 0, 0, - 0, 0, 1652, 0, 0, 0, 0, 0, 1659, 0, - 1653, 1660, 0, 0, 0, 0, 0, 0, 1663, 0, - 0, 0, 0, 0, 0, 1661, 0, 1654, 1662, 0, - 0, 0, 1655, 0, 0, 0, 0, 0, 0, 1664, + 1639, 0, 0, 1640, 0, 0, 1661, 1641, 1642, 1662, + 0, 1645, 1646, 1647, 0, 0, 0, 0, 0, 1639, + 0, 1663, 1640, 0, 0, 0, 1641, 1642, 1643, 1644, + 1645, 1646, 1647, 0, 0, 0, 0, 0, 1650, 0, + 0, 0, 0, 0, 0, 1651, 0, 1648, 0, 0, + 0, 1664, 0, 0, 1665, 1666, 1667, 1650, 1668, 1669, + 1670, 1671, 1672, 1673, 1651, 0, 0, 0, 3503, 0, + 0, 0, 1652, 0, 0, 0, 1639, 0, 0, 1640, + 0, 0, 0, 1641, 1642, 1643, 1644, 1645, 1646, 1647, + 1664, 1652, 0, 1665, 1666, 1667, 0, 1668, 1669, 1670, + 1671, 1672, 1673, 0, 1648, 0, 0, 3525, 1663, 0, + 0, 0, 0, 0, 1650, 0, 0, 0, 0, 0, + 0, 1651, 0, 0, 0, 0, 0, 0, 0, 1664, 0, 0, 1665, 1666, 1667, 0, 1668, 1669, 1670, 1671, - 1672, 1673, 0, 0, 0, 1838, 1657, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1658, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1672, 1673, 0, 0, 1827, 0, 0, 0, 1652, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1653, - 0, 0, 0, 0, 0, 0, 0, 0, 1659, 0, - 0, 1660, 0, 0, 0, 0, 1654, 0, 0, 0, - 0, 1655, 0, 0, 0, 1661, 1664, 1663, 1662, 1665, - 1666, 1667, 0, 1668, 1669, 1670, 1671, 1672, 1673, 0, - 0, 0, 0, 0, 1656, 1657, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1658, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1654, 0, 1653, 0, + 0, 1655, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1654, 0, 0, 0, 0, + 1655, 0, 0, 0, -2102, -2102, 1664, 0, 0, 1665, + 1666, 1667, 0, 1668, 1669, 1670, 1671, 1672, 1673, 1658, + 0, 2873, 0, 1656, 1657, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1653, 0, 0, 1658, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1654, 0, 0, 0, 0, 1655, 0, 0, + -2102, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1661, 0, 1659, 0, 0, 1660, + 1656, 1657, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1661, 0, 1658, 1662, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1659, 0, 0, - 1660, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1661, 0, 0, 1662, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1663, 0, 0, - 0, 0, 0, 0, 0, 1664, 0, 0, 1665, 1666, - 1667, 0, 1668, 1669, 1670, 1671, 1672, 1673, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1659, 0, 0, 1660, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1661, 0, 0, 1662, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1663, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1663, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1663, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1664, 0, 0, 1665, 1666, - 1667, 0, 1668, 1669, 1670, 1671, 1672, 1673, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1663, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1664, 0, 0, 1665, 1666, 1667, + 0, 1668, 1669, 1670, 1671, 1672, 1673, 0, 0, 0, + 0, 0, 0, 1664, 0, 0, 1665, 1666, 1667, 0, + 1668, 1669, 1670, 1671, 1672, 1673, 0, 0, 3315, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 560, 0, - 2130, 0, 0, 0, 1664, 0, 0, 1665, 1666, 1667, - 0, 1668, 1669, 1670, 1671, 2235, 1673, 118, 119, 120, - 121, 122, 123, 124, 125, 561, 126, 127, 128, 562, - 563, 564, 565, 566, 567, 568, 569, 570, 130, 131, - 571, 132, 133, 134, 572, 136, 137, 138, 573, 574, - 575, 576, 577, 578, 144, 145, 146, 147, 148, 149, - 579, 580, 150, 151, 152, 153, 581, 582, 156, 583, - 157, 158, 159, 160, 584, 585, 586, 587, 588, 164, - 165, 166, 167, 168, 589, 170, 171, 172, 590, 173, - 174, 175, 176, 177, 178, 591, 592, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 594, 191, 192, - 595, 194, 596, 195, 597, 196, 197, 198, 199, 200, - 201, 598, 599, 202, 203, 204, 205, 600, 601, 206, - 207, 208, 209, 210, 602, 211, 212, 213, 603, 214, - 215, 216, 604, 217, 218, 219, 220, 605, 222, 223, - 224, 225, 226, 227, 606, 607, 229, 608, 230, 231, - 609, 233, 610, 234, 611, 235, 612, 613, 614, 238, - 239, 615, 616, 242, 617, 243, 618, 619, 620, 246, - 247, 621, 248, 249, 250, 251, 252, 253, 254, 622, - 256, 257, 258, 259, 623, 260, 261, 262, 263, 264, - 265, 266, 624, 267, 625, 626, 270, 271, 272, 273, - 274, 627, 628, 629, 630, 631, 278, 632, 633, 281, - 634, 283, 284, 285, 286, 287, 288, 635, 636, 289, - 637, 291, 638, 639, 293, 294, 295, 296, 297, 298, - 299, 300, 640, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 641, 642, 643, 325, 326, 327, 644, - 645, 329, 330, 646, 332, 647, 648, 334, 649, 336, - 337, 338, 650, 339, 340, 651, 652, 341, 342, 343, - 653, 654, 344, 345, 655, 656, 348, 657, 658, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, - 659, 660, 661, 662, 362, 363, 663, 664, 366, 367, - 665, 369, 370, 371, 666, 372, 373, 374, 375, 376, - 377, 667, 378, 379, 380, 381, 382, 668, 384, 385, - 386, 387, 669, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 397, 398, 399, 400, 670, 401, 402, 671, - 404, 405, 406, 672, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 417, 418, 419, 420, 673, 674, 421, - 422, 423, 424, 425, 426, 675, 428, 429, 676, 677, - 431, 432, 678, 434, 679, 435, 436, 437, 438, 439, - 440, 441, 442, 443, 444, 445, 446, 680, 448, 681, - 682, 683, 450, 451, 684, 452, 685, 454, 455, 456, - 457, 458, 686, 459, 687, 688, 689, 690, 462, 463, - 691, 465, 692, 693, 467, 468, 694, 470, 471, 472, - 473, 474, 695, 696, 475, 476, 477, 697, 478, 479, - 480, 481, 698, 482, 483, 484, 485, 486, 699, 700, - 489, 701, 490, 702, 492, 493, 494, 495, 496, 497, - 498, 703, 704, 499, 705, 706, 500, 501, 502, 503, - 504, 505, 707, 708, 709, 710, 711, 712, 713, 714, - 715, 716, 717, 517, 518, 519, 520, 560, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 560, 0, 0, + 1664, 0, 0, 1665, 1666, 1667, 0, 1668, 1669, 1670, + 1671, 1672, 1673, 0, 0, 3487, 118, 119, 120, 121, 122, 123, 124, 125, 561, 126, 127, 128, 562, 563, 564, 565, 566, 567, 568, 569, 570, 130, 131, 571, 132, 133, 134, 572, 136, 137, 138, 573, 574, 575, @@ -9254,7 +8807,7 @@ static const yytype_int16 yytable[] = 158, 159, 160, 584, 585, 586, 587, 588, 164, 165, 166, 167, 168, 589, 170, 171, 172, 590, 173, 174, 175, 176, 177, 178, 591, 592, 180, 181, 182, 183, - 184, 185, 593, 187, 188, 189, 594, 191, 192, 595, + 184, 185, 186, 187, 188, 189, 594, 191, 192, 595, 194, 596, 195, 597, 196, 197, 198, 199, 200, 201, 598, 599, 202, 203, 204, 205, 600, 601, 206, 207, 208, 209, 210, 602, 211, 212, 213, 603, 214, 215, @@ -9293,109 +8846,349 @@ static const yytype_int16 yytable[] = 701, 490, 702, 492, 493, 494, 495, 496, 497, 498, 703, 704, 499, 705, 706, 500, 501, 502, 503, 504, 505, 707, 708, 709, 710, 711, 712, 713, 714, 715, - 716, 717, 517, 518, 519, 520, 560, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 716, 717, 517, 518, 519, 520, 528, 0, 0, 0, + 0, 0, 0, 0, 0, 2115, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 561, 126, 127, 128, 562, 563, 564, - 565, 566, 567, 568, 569, 570, 130, 131, 571, 132, - 133, 134, 572, 136, 137, 138, 573, 574, 575, 576, - 577, 578, 144, 145, 146, 147, 148, 149, 579, 580, - 150, 151, 152, 153, 581, 582, 156, 583, 157, 158, - 159, 160, 584, 585, 586, 587, 588, 164, 165, 166, - 167, 168, 589, 170, 171, 172, 590, 173, 174, 175, - 176, 177, 178, 591, 592, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 594, 191, 192, 595, 194, - 596, 195, 597, 196, 197, 198, 199, 200, 201, 598, - 599, 202, 203, 204, 205, 600, 601, 206, 207, 208, - 209, 210, 602, 211, 212, 213, 603, 214, 215, 216, - 604, 217, 218, 219, 220, 605, 222, 223, 224, 225, - 226, 227, 606, 607, 229, 608, 230, 231, 609, 233, - 610, 234, 611, 235, 612, 613, 614, 238, 239, 615, - 616, 242, 617, 243, 618, 619, 620, 246, 247, 621, - 248, 249, 250, 251, 252, 950, 254, 622, 256, 257, - 258, 259, 623, 260, 261, 262, 263, 264, 265, 266, - 624, 267, 625, 626, 270, 271, 272, 273, 274, 627, - 628, 629, 630, 631, 278, 632, 633, 281, 634, 283, - 284, 285, 286, 287, 288, 635, 636, 289, 637, 291, - 638, 639, 293, 294, 295, 296, 297, 298, 299, 300, - 640, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 641, 642, 643, 325, 326, 327, 644, 645, 329, - 330, 646, 332, 647, 648, 334, 649, 336, 337, 338, - 650, 339, 340, 651, 652, 341, 342, 343, 653, 654, - 344, 345, 655, 656, 348, 657, 658, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 659, 660, - 661, 662, 362, 363, 663, 664, 366, 367, 665, 369, - 370, 371, 666, 372, 373, 374, 375, 376, 377, 667, - 378, 379, 380, 381, 382, 668, 384, 385, 386, 387, - 669, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 670, 401, 402, 671, 404, 405, - 406, 672, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 673, 674, 421, 422, 423, - 424, 425, 426, 675, 428, 429, 676, 677, 431, 432, - 678, 434, 679, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 680, 448, 681, 682, 683, - 450, 451, 684, 452, 685, 454, 455, 456, 457, 458, - 686, 459, 687, 688, 689, 690, 462, 463, 691, 465, - 692, 693, 467, 468, 694, 470, 471, 472, 473, 474, - 695, 696, 475, 476, 477, 697, 478, 479, 480, 481, - 698, 482, 483, 484, 485, 486, 699, 700, 489, 701, - 490, 702, 492, 493, 494, 495, 496, 497, 498, 703, - 704, 499, 705, 706, 500, 501, 502, 503, 504, 505, - 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, - 717, 517, 518, 519, 520, 560, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, - 124, 125, 561, 126, 127, 128, 562, 563, 564, 565, - 566, 567, 568, 569, 570, 130, 131, 571, 132, 133, - 134, 572, 136, 137, 138, 573, 574, 575, 576, 577, - 578, 144, 145, 146, 147, 148, 149, 579, 580, 150, - 151, 152, 153, 581, 582, 156, 583, 157, 158, 159, - 160, 584, 585, 586, 587, 588, 164, 165, 166, 167, - 168, 589, 170, 171, 172, 590, 173, 174, 175, 176, - 177, 178, 591, 592, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 594, 191, 192, 595, 194, 596, - 195, 597, 196, 197, 198, 199, 200, 201, 598, 599, - 202, 203, 204, 205, 600, 601, 206, 207, 208, 209, - 210, 602, 211, 212, 213, 603, 214, 215, 216, 604, - 217, 218, 219, 220, 605, 222, 223, 224, 225, 226, - 227, 606, 607, 229, 608, 230, 231, 609, 233, 610, - 234, 611, 235, 612, 613, 614, 238, 239, 615, 616, - 242, 617, 243, 618, 619, 620, 246, 247, 621, 248, - 249, 250, 251, 252, 253, 254, 622, 256, 257, 258, - 259, 623, 260, 261, 262, 263, 264, 265, 266, 624, - 267, 625, 626, 270, 271, 272, 273, 274, 627, 628, - 629, 630, 631, 278, 632, 633, 281, 634, 283, 284, - 285, 286, 287, 288, 635, 636, 289, 637, 291, 638, - 639, 293, 294, 295, 296, 297, 298, 299, 300, 640, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, - 641, 642, 643, 325, 326, 327, 644, 645, 329, 330, - 646, 332, 647, 648, 334, 649, 336, 337, 338, 650, - 339, 340, 651, 652, 341, 342, 343, 653, 654, 344, - 345, 655, 656, 348, 657, 658, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, 361, 659, 660, 661, - 662, 362, 363, 663, 664, 366, 367, 665, 369, 370, - 371, 666, 372, 373, 374, 375, 376, 377, 667, 378, - 379, 380, 381, 382, 668, 384, 385, 386, 387, 669, - 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, - 398, 399, 400, 670, 401, 402, 671, 404, 405, 406, - 672, 408, 409, 410, 411, 412, 413, 414, 415, 416, - 417, 418, 419, 420, 673, 674, 421, 422, 423, 424, - 425, 426, 675, 428, 429, 676, 677, 431, 432, 678, - 434, 679, 435, 436, 437, 438, 439, 440, 441, 442, - 443, 444, 445, 446, 680, 448, 681, 682, 683, 450, - 451, 684, 452, 685, 454, 455, 456, 457, 458, 686, - 459, 687, 688, 689, 690, 462, 463, 691, 465, 692, - 693, 467, 468, 694, 470, 471, 472, 473, 474, 695, - 696, 475, 476, 477, 697, 478, 479, 480, 481, 698, - 482, 483, 484, 485, 486, 699, 700, 489, 701, 490, - 702, 492, 493, 494, 495, 496, 497, 498, 703, 704, - 499, 705, 706, 500, 501, 502, 503, 504, 505, 707, - 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, - 517, 518, 519, 520, 560, 0, 0, 0, 0, 0, + 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, + 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, + 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, + 150, 151, 152, 153, 154, 155, 156, 0, 157, 158, + 159, 160, 161, 0, 0, 0, 163, 164, 165, 166, + 167, 168, 0, 170, 171, 172, 0, 173, 174, 175, + 176, 177, 178, 0, 0, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, + 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, + 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, + 0, 217, 218, 219, 220, 221, 222, 223, 224, 225, + 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, + 0, 234, 0, 235, 0, 0, 0, 238, 239, 529, + 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, + 248, 249, 250, 251, 252, 253, 254, 0, 256, 257, + 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, + 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, + 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, + 284, 285, 286, 287, 288, 0, 0, 289, 0, 291, + 0, 0, 293, 294, 295, 296, 297, 298, 299, 300, + 530, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 0, 324, 325, 326, 327, 328, 0, 329, + 330, 0, 332, 0, 333, 334, 335, 336, 337, 338, + 0, 339, 340, 0, 0, 341, 342, 343, 0, 0, + 344, 345, 346, 0, 348, 0, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, + 0, 0, 362, 363, 364, 0, 366, 367, 368, 369, + 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, + 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, + 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, + 397, 398, 399, 400, 0, 401, 402, 0, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, + 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, + 424, 425, 426, 427, 428, 429, 0, 0, 431, 432, + 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, + 442, 443, 444, 445, 446, 531, 448, 449, 0, 0, + 450, 451, 0, 452, 0, 454, 455, 456, 457, 458, + 0, 459, 460, 461, 0, 0, 462, 463, 464, 465, + 466, 0, 467, 468, 469, 470, 471, 472, 473, 474, + 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, + 0, 482, 483, 484, 485, 486, 487, 488, 489, 0, + 490, 0, 492, 493, 494, 495, 496, 497, 498, 0, + 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, + 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, + 516, 517, 518, 519, 520, 528, 0, 0, 0, 0, + 0, 0, 0, 0, 2766, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, + 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, + 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, + 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, + 151, 152, 153, 154, 155, 156, 0, 157, 158, 159, + 160, 161, 0, 0, 0, 163, 164, 165, 166, 167, + 168, 0, 170, 171, 172, 0, 173, 174, 175, 176, + 177, 178, 0, 0, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 0, + 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, + 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, + 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, + 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, + 234, 0, 235, 0, 0, 0, 238, 239, 529, 0, + 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, + 249, 250, 251, 252, 253, 254, 0, 256, 257, 258, + 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, + 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, + 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, + 285, 286, 287, 288, 0, 0, 289, 0, 291, 0, + 0, 293, 294, 295, 296, 297, 298, 299, 300, 530, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 0, 324, 325, 326, 327, 328, 0, 329, 330, + 0, 332, 0, 333, 334, 335, 336, 337, 338, 0, + 339, 340, 0, 0, 341, 342, 343, 0, 0, 344, + 345, 346, 0, 348, 0, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, + 0, 362, 363, 364, 0, 366, 367, 368, 369, 370, + 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, + 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, + 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, + 398, 399, 400, 0, 401, 402, 0, 404, 405, 406, + 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, + 425, 426, 427, 428, 429, 0, 0, 431, 432, 433, + 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, + 443, 444, 445, 446, 531, 448, 449, 0, 0, 450, + 451, 0, 452, 0, 454, 455, 456, 457, 458, 0, + 459, 460, 461, 0, 0, 462, 463, 464, 465, 466, + 0, 467, 468, 469, 470, 471, 472, 473, 474, 0, + 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, + 482, 483, 484, 485, 486, 487, 488, 489, 0, 490, + 0, 492, 493, 494, 495, 496, 497, 498, 0, 0, + 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, + 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, + 517, 518, 519, 520, 974, 1364, 821, 0, 0, 0, + 1060, 0, 0, 2769, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, + 125, 0, 126, 127, 128, 0, 0, 0, 565, 0, + 0, 0, 0, 570, 130, 131, 0, 132, 133, 134, + 572, 136, 137, 138, 573, 574, 575, 576, 577, 0, + 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, + 152, 153, 581, 582, 156, 0, 157, 158, 159, 160, + 584, 0, 586, 0, 588, 164, 165, 166, 167, 168, + 589, 170, 171, 172, 0, 173, 174, 175, 176, 177, + 178, 0, 592, 180, 181, 182, 183, 184, 185, 186, + 187, 188, 189, 594, 191, 192, 595, 194, 0, 195, + 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, + 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, + 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, + 218, 219, 220, 605, 222, 223, 224, 225, 226, 227, + 606, 1365, 229, 0, 230, 231, 609, 233, 0, 234, + 0, 235, 612, 0, 614, 238, 239, 615, 616, 242, + 0, 243, 0, 619, 620, 246, 247, 0, 248, 249, + 250, 251, 252, 253, 254, 622, 256, 257, 258, 259, + 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, + 625, 626, 270, 271, 272, 273, 274, 627, 628, 0, + 630, 0, 278, 632, 633, 281, 634, 283, 284, 285, + 286, 287, 288, 0, 0, 289, 637, 291, 638, 0, + 293, 294, 295, 296, 297, 298, 299, 300, 640, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 320, 321, 641, + 642, 643, 325, 326, 327, 644, 0, 329, 330, 646, + 332, 0, 648, 334, 649, 336, 337, 338, 0, 339, + 340, 1366, 0, 341, 342, 343, 0, 0, 344, 345, + 655, 656, 348, 657, 658, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, + 362, 363, 663, 664, 366, 367, 665, 369, 370, 371, + 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, + 380, 381, 382, 668, 384, 385, 386, 387, 0, 388, + 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, + 399, 400, 0, 401, 402, 671, 404, 405, 406, 672, + 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, + 418, 419, 420, 0, 674, 421, 422, 423, 424, 425, + 426, 675, 428, 429, 0, 677, 431, 432, 678, 434, + 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, + 444, 445, 446, 680, 448, 681, 0, 0, 450, 451, + 0, 452, 685, 454, 455, 456, 457, 458, 0, 459, + 687, 688, 0, 0, 462, 463, 691, 465, 692, 1367, + 467, 468, 694, 470, 471, 472, 473, 474, 0, 0, + 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, + 483, 484, 485, 486, 699, 700, 489, 0, 490, 702, + 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, + 0, 0, 500, 501, 502, 503, 504, 505, 707, 708, + 709, 710, 711, 712, 713, 714, 715, 716, 717, 517, + 518, 519, 520, 0, 0, 1639, 0, 0, 1640, 0, + 1368, 1369, 1641, 1642, 1643, 1644, 1645, 1646, 1647, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1648, 0, 0, 0, 0, 2216, 0, + 0, 0, 0, 1650, 1639, 0, 0, 1640, 0, 0, + 1651, 1641, 1642, 1643, 1644, 1645, 1646, 1647, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1648, 0, 0, 0, 0, 1652, 0, 0, + 0, 0, 1650, 1639, 0, 0, 1640, 0, 0, 1651, + 1641, 1642, 1643, 1644, 1645, 1646, 1647, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1648, 0, 0, 0, 0, 1652, 0, 0, 0, + 0, 1650, 0, 2217, 0, 0, 0, 0, 1651, 0, + 1639, 0, 0, 1640, 0, 0, 0, 1641, 1642, 1643, + 1644, 1645, 1646, 1647, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1652, 0, 0, 1648, 0, + 0, 0, 1929, 0, 0, 0, 0, 0, 1650, 0, + 0, 0, 0, 0, 1653, 1651, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1654, 0, 0, 0, 0, 1655, 0, 0, 0, + 0, 0, 1652, 1965, 0, 0, 0, 0, 1966, 0, + 0, 0, 0, 1653, 0, 0, 0, 0, 0, 1656, + 1657, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1654, 0, 0, 0, 1658, 1655, 0, 0, 0, 0, + 0, 3593, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1653, 0, 0, 0, 0, 0, 1656, 1657, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1654, + 0, 0, 1659, 1658, 1655, 1660, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1661, + 0, 0, 1662, 0, 0, 0, 0, 1656, 1657, 1653, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1659, 1658, 0, 1660, 0, 1654, 0, 0, 0, + 0, 1655, 0, 0, 0, 0, 0, 0, 1661, 0, + 0, 1662, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1656, 1657, 0, 0, 0, 0, + 1659, 0, 0, 1660, 0, 0, 0, 0, 0, 1658, + 0, 0, 0, 0, 0, 0, 0, 1661, 0, 0, + 1662, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1663, 0, 0, 0, 0, 0, 1659, 0, 3594, + 1660, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1661, 0, 0, 1662, 0, 0, + 0, 0, 0, 0, 0, 1639, 0, 0, 1640, 0, + 1663, 0, 1641, 1642, 1643, 1644, 1645, 1646, 1647, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1648, 2220, 0, 0, 0, 0, 0, + 0, 0, 0, 1650, 0, 0, 0, 0, 0, 1663, + 1651, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1652, 0, 1664, + 0, 0, 1665, 1666, 1667, 0, 1668, 1669, 1670, 1671, + 1672, 1673, 0, 0, 0, 0, 1663, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1664, 0, + 0, 1665, 1666, 1667, 0, 1668, 1669, 1670, 1671, 1672, + 1673, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1664, 0, 0, + 1665, 1666, 1667, 0, 1668, 1669, 1670, 1671, 1672, 1673, + 0, 0, 0, 0, 1653, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1639, 1654, 0, 1640, 0, 0, 1655, 1641, 1642, 1643, + 1644, 1645, 1646, 1647, 1664, 0, 0, 1665, 1666, 1667, + 0, 1668, 1669, 1670, 1671, 1672, 1673, 0, 1648, 1656, + 1657, 0, 1971, 0, 0, 0, 0, 0, 1650, 0, + 0, 0, 0, 0, 1658, 1651, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1639, 0, 0, 1640, + 0, 0, 1652, 1641, 1642, 1643, 1644, 1645, 1646, 1647, + 0, 0, 1659, 0, 0, 1660, 0, 0, 0, 0, + 0, 0, 0, 0, 1648, 0, 0, 0, 0, 1661, + 0, 0, 1662, 0, 1650, 0, 0, 0, 0, 0, + 0, 1651, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1936, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1652, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1639, 0, 0, 1640, 0, + 0, 0, 1641, 1642, 1643, 1644, 1645, 1646, 1647, 1653, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1648, 0, 0, 1654, 1978, 0, 0, + 0, 1655, 0, 1650, 0, 0, 0, 0, 0, 0, + 1651, 1663, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1656, 1657, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1652, 0, 1658, + 1976, 0, 0, 0, 0, 1653, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1654, 0, 0, 0, 0, 1655, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1659, 0, 0, + 1660, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1656, 1657, 0, 0, 1661, 0, 0, 1662, 0, 0, + 0, 0, 0, 0, 0, 1658, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1664, + 0, 0, 1665, 1666, 1667, 0, 1668, 1669, 1670, 1671, + 1672, 1673, 0, 0, 1653, 0, 0, 0, 0, 0, + 0, 0, 0, 1659, 0, 0, 1660, 0, 0, 0, + 0, 1654, 0, 0, 0, 0, 1655, 0, 0, 0, + 1661, 0, 0, 1662, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1639, 0, 0, 1640, 0, 1656, + 1657, 1641, 1642, 1643, 1644, 1645, 1646, 1647, 0, 0, + 0, 0, 0, 0, 1658, 0, 1663, 0, 0, 0, + 0, 0, 1648, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1650, 0, 0, 0, 0, 0, 0, 1651, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1639, 1659, 0, 1640, 1660, 0, 0, 1641, 1642, + 1643, 1644, 1645, 1646, 1647, 0, 1652, 0, 0, 1661, + 0, 0, 1662, 0, 0, 0, 0, 0, 0, 1648, + 0, 0, 1663, 0, 0, 0, 0, 0, 0, 1650, + 0, 0, 0, 0, 0, 0, 1651, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1652, 1664, 0, 0, 1665, 1666, 1667, + 0, 1668, 1669, 1670, 1671, 1672, 1673, 0, 1639, 0, + 0, 1640, 0, 0, 0, 1641, 1642, 1643, 1644, 1645, + 1646, 1647, 0, 2108, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1653, 0, 0, 1648, 0, 0, 0, + 2846, 1663, 0, 0, 0, 0, 1650, 0, 0, 0, + 1654, 0, 0, 1651, 0, 1655, 0, 0, 0, 0, + 1664, 0, 0, 1665, 1666, 1667, 0, 1668, 1669, 1670, + 1671, 1672, 1673, 0, 0, 0, 0, 0, 1656, 1657, + 1652, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1653, 0, 0, 1658, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1654, 0, 0, + 0, 0, 1655, 0, 0, 0, 0, 1639, 0, 0, + 1640, 0, 0, 0, 1641, 1642, 1643, 1644, 1645, 1646, + 1647, 1659, 0, 0, 1660, 1656, 1657, 0, 0, 0, + 0, 0, 0, 0, 0, 1648, 0, 0, 1661, 1664, + 1658, 1662, 1665, 1666, 1667, 1650, 1668, 1669, 1670, 1671, + 1672, 1673, 1651, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1653, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1659, 1652, + 0, 1660, 0, 0, 1654, 0, 0, 0, 0, 1655, + 0, 0, 0, 0, 0, 1661, 0, 0, 1662, 0, + 0, 0, 0, 0, 0, 0, 0, 1639, 0, 0, + 1640, 0, 1656, 1657, 1641, 1642, 1643, 1644, 1645, 1646, + 1647, 0, 0, 0, 0, 0, 0, 1658, 0, 0, + 0, 0, 0, 0, 0, 1648, 0, 0, 0, 0, + 1663, 0, 0, 0, 0, 1650, 0, 0, 0, 0, + 0, 0, 1651, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1659, 0, 0, 1660, 0, + 0, 0, 0, 0, 0, 0, 1653, 0, 0, 1652, + 0, 0, 1661, 0, 0, 1662, 0, 0, 0, 0, + 0, 0, 0, 1654, 0, 0, 1639, 1663, 1655, 1640, + 0, 0, 0, 1641, 1642, 1643, 1644, 1645, 1646, 1647, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1656, 1657, 0, 1648, 0, 0, 0, 0, 0, + 2830, 0, 0, 0, 1650, 0, 1658, 0, 0, 0, + 0, 1651, 0, 0, 0, 0, 0, 0, 1664, 0, + 0, 1665, 1666, 1667, 0, 1668, 1669, 1670, 1671, 1672, + 1673, 0, 0, 0, 0, 0, 0, 0, 1652, 0, + 0, 0, 0, 0, 1659, 0, 1653, 1660, 0, 0, + 0, 0, 0, 0, 1663, 0, 0, 0, 0, 0, + 0, 1661, 0, 1654, 1662, 0, 0, 0, 1655, 0, + 0, 0, 0, 0, 0, 1664, 0, 0, 1665, 1666, + 1667, 0, 1668, 1669, 1670, 1671, 1672, 1673, 0, 0, + 0, 1840, 1657, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1658, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1653, 0, 0, 0, 0, + 0, 0, 0, 0, 1659, 0, 0, 1660, 0, 0, + 0, 0, 1654, 0, 0, 0, 0, 1655, 0, 0, + 0, 1661, 1664, 1663, 1662, 1665, 1666, 1667, 0, 1668, + 1669, 1670, 1671, 1672, 1673, 0, 0, 0, 0, 0, + 1656, 1657, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1658, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1659, 0, 0, 1660, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1661, 0, 0, 1662, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1663, 0, 0, 0, 0, 0, 0, + 0, 1664, 0, 0, 1665, 1666, 1667, 0, 1668, 1669, + 1670, 1671, 1672, 1673, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 118, 119, 120, 121, 2284, 123, 124, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1663, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1664, 0, 0, 1665, 1666, 1667, 0, 1668, 1669, + 1670, 1671, 1672, 1673, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 560, 0, 2132, 0, 0, 0, + 1664, 0, 0, 1665, 1666, 1667, 0, 1668, 1669, 1670, + 1671, 2237, 1673, 118, 119, 120, 121, 122, 123, 124, 125, 561, 126, 127, 128, 562, 563, 564, 565, 566, 567, 568, 569, 570, 130, 131, 571, 132, 133, 134, 572, 136, 137, 138, 573, 574, 575, 576, 577, 578, @@ -9406,7 +9199,7 @@ static const yytype_int16 yytable[] = 178, 591, 592, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 594, 191, 192, 595, 194, 596, 195, 597, 196, 197, 198, 199, 200, 201, 598, 599, 202, - 203, 204, 205, 600, 601, 206, 207, 208, 2285, 210, + 203, 204, 205, 600, 601, 206, 207, 208, 209, 210, 602, 211, 212, 213, 603, 214, 215, 216, 604, 217, 218, 219, 220, 605, 222, 223, 224, 225, 226, 227, 606, 607, 229, 608, 230, 231, 609, 233, 610, 234, @@ -9432,7 +9225,7 @@ static const yytype_int16 yytable[] = 399, 400, 670, 401, 402, 671, 404, 405, 406, 672, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 673, 674, 421, 422, 423, 424, 425, - 2286, 675, 428, 429, 676, 677, 431, 432, 678, 434, + 426, 675, 428, 429, 676, 677, 431, 432, 678, 434, 679, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 680, 448, 681, 682, 683, 450, 451, 684, 452, 685, 454, 455, 456, 457, 458, 686, 459, @@ -9443,415 +9236,415 @@ static const yytype_int16 yytable[] = 492, 493, 494, 495, 496, 497, 498, 703, 704, 499, 705, 706, 500, 501, 502, 503, 504, 505, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 517, - 518, 519, 520, 974, 0, 821, 0, 0, 0, 0, + 518, 519, 520, 560, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, - 0, 126, 127, 128, 0, 0, 0, 565, 0, 0, - 0, 0, 570, 130, 131, 0, 132, 133, 134, 572, - 136, 137, 138, 573, 574, 575, 576, 577, 0, 144, - 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, - 153, 581, 582, 156, 0, 157, 158, 159, 160, 584, - 0, 586, 0, 588, 164, 165, 166, 167, 168, 589, - 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, - 0, 592, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 594, 191, 192, 595, 194, 0, 195, 0, - 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, - 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, - 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, + 561, 126, 127, 128, 562, 563, 564, 565, 566, 567, + 568, 569, 570, 130, 131, 571, 132, 133, 134, 572, + 136, 137, 138, 573, 574, 575, 576, 577, 578, 144, + 145, 146, 147, 148, 149, 579, 580, 150, 151, 152, + 153, 581, 582, 156, 583, 157, 158, 159, 160, 584, + 585, 586, 587, 588, 164, 165, 166, 167, 168, 589, + 170, 171, 172, 590, 173, 174, 175, 176, 177, 178, + 591, 592, 180, 181, 182, 183, 184, 185, 593, 187, + 188, 189, 594, 191, 192, 595, 194, 596, 195, 597, + 196, 197, 198, 199, 200, 201, 598, 599, 202, 203, + 204, 205, 600, 601, 206, 207, 208, 209, 210, 602, + 211, 212, 213, 603, 214, 215, 216, 604, 217, 218, 219, 220, 605, 222, 223, 224, 225, 226, 227, 606, - 1365, 229, 0, 230, 231, 609, 233, 0, 234, 0, - 235, 612, 0, 614, 238, 239, 615, 616, 242, 0, - 243, 0, 619, 620, 246, 247, 0, 248, 249, 250, - 251, 252, 253, 254, 622, 256, 257, 258, 259, 0, - 260, 261, 262, 263, 264, 265, 266, 0, 267, 625, - 626, 270, 271, 272, 273, 274, 627, 628, 0, 630, - 0, 278, 632, 633, 281, 634, 283, 284, 285, 286, - 287, 288, 0, 0, 289, 637, 291, 638, 0, 293, + 607, 229, 608, 230, 231, 609, 233, 610, 234, 611, + 235, 612, 613, 614, 238, 239, 615, 616, 242, 617, + 243, 618, 619, 620, 246, 247, 621, 248, 249, 250, + 251, 252, 253, 254, 622, 256, 257, 258, 259, 623, + 260, 261, 262, 263, 264, 265, 266, 624, 267, 625, + 626, 270, 271, 272, 273, 274, 627, 628, 629, 630, + 631, 278, 632, 633, 281, 634, 283, 284, 285, 286, + 287, 288, 635, 636, 289, 637, 291, 638, 639, 293, 294, 295, 296, 297, 298, 299, 300, 640, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 641, 642, - 643, 325, 326, 327, 644, 0, 329, 330, 646, 332, - 0, 648, 334, 649, 336, 337, 338, 0, 339, 340, - 1366, 0, 341, 342, 343, 0, 0, 344, 345, 655, + 643, 325, 326, 327, 644, 645, 329, 330, 646, 332, + 647, 648, 334, 649, 336, 337, 338, 650, 339, 340, + 651, 652, 341, 342, 343, 653, 654, 344, 345, 655, 656, 348, 657, 658, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, - 363, 663, 664, 366, 367, 665, 369, 370, 371, 0, - 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, - 381, 382, 668, 384, 385, 386, 387, 0, 388, 389, + 357, 358, 359, 360, 361, 659, 660, 661, 662, 362, + 363, 663, 664, 366, 367, 665, 369, 370, 371, 666, + 372, 373, 374, 375, 376, 377, 667, 378, 379, 380, + 381, 382, 668, 384, 385, 386, 387, 669, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, - 400, 0, 401, 402, 671, 404, 405, 406, 672, 408, + 400, 670, 401, 402, 671, 404, 405, 406, 672, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, - 419, 420, 0, 674, 421, 422, 423, 424, 425, 426, - 675, 428, 429, 0, 677, 431, 432, 678, 434, 0, + 419, 420, 673, 674, 421, 422, 423, 424, 425, 426, + 675, 428, 429, 676, 677, 431, 432, 678, 434, 679, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, - 445, 446, 680, 448, 681, 0, 0, 450, 451, 0, - 452, 685, 454, 455, 456, 457, 458, 0, 459, 687, - 688, 0, 0, 462, 463, 691, 465, 692, 1367, 467, - 468, 694, 470, 471, 472, 473, 474, 0, 0, 475, - 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, - 484, 485, 486, 699, 700, 489, 0, 490, 702, 492, - 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, - 0, 500, 501, 502, 503, 504, 505, 707, 708, 709, + 445, 446, 680, 448, 681, 682, 683, 450, 451, 684, + 452, 685, 454, 455, 456, 457, 458, 686, 459, 687, + 688, 689, 690, 462, 463, 691, 465, 692, 693, 467, + 468, 694, 470, 471, 472, 473, 474, 695, 696, 475, + 476, 477, 697, 478, 479, 480, 481, 698, 482, 483, + 484, 485, 486, 699, 700, 489, 701, 490, 702, 492, + 493, 494, 495, 496, 497, 498, 703, 704, 499, 705, + 706, 500, 501, 502, 503, 504, 505, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 517, 518, - 519, 520, 974, 0, 0, 0, 0, 0, 0, 0, + 519, 520, 560, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, - 126, 127, 128, 3, 4, 0, 565, 0, 0, 0, - 0, 570, 130, 131, 0, 132, 133, 134, 572, 136, - 137, 138, 573, 574, 575, 576, 577, 0, 144, 145, - 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, - 581, 582, 156, 0, 157, 158, 159, 160, 584, 0, - 586, 0, 588, 164, 165, 166, 167, 168, 589, 170, - 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, + 0, 118, 119, 120, 121, 122, 123, 124, 125, 561, + 126, 127, 128, 562, 563, 564, 565, 566, 567, 568, + 569, 570, 130, 131, 571, 132, 133, 134, 572, 136, + 137, 138, 573, 574, 575, 576, 577, 578, 144, 145, + 146, 147, 148, 149, 579, 580, 150, 151, 152, 153, + 581, 582, 156, 583, 157, 158, 159, 160, 584, 585, + 586, 587, 588, 164, 165, 166, 167, 168, 589, 170, + 171, 172, 590, 173, 174, 175, 176, 177, 178, 591, 592, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 189, 594, 191, 192, 595, 194, 0, 195, 0, 196, - 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, - 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, - 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, - 220, 605, 222, 223, 224, 225, 226, 227, 606, 0, - 229, 0, 230, 231, 609, 233, 0, 234, 0, 235, - 612, 0, 614, 238, 239, 615, 616, 242, 0, 243, - 0, 619, 620, 246, 247, 0, 248, 249, 250, 251, - 252, 253, 254, 622, 256, 257, 258, 259, 0, 260, - 261, 262, 263, 264, 265, 266, 0, 267, 625, 626, - 270, 271, 272, 273, 274, 627, 628, 0, 630, 0, + 189, 594, 191, 192, 595, 194, 596, 195, 597, 196, + 197, 198, 199, 200, 201, 598, 599, 202, 203, 204, + 205, 600, 601, 206, 207, 208, 209, 210, 602, 211, + 212, 213, 603, 214, 215, 216, 604, 217, 218, 219, + 220, 605, 222, 223, 224, 225, 226, 227, 606, 607, + 229, 608, 230, 231, 609, 233, 610, 234, 611, 235, + 612, 613, 614, 238, 239, 615, 616, 242, 617, 243, + 618, 619, 620, 246, 247, 621, 248, 249, 250, 251, + 252, 950, 254, 622, 256, 257, 258, 259, 623, 260, + 261, 262, 263, 264, 265, 266, 624, 267, 625, 626, + 270, 271, 272, 273, 274, 627, 628, 629, 630, 631, 278, 632, 633, 281, 634, 283, 284, 285, 286, 287, - 288, 0, 0, 289, 637, 291, 638, 0, 293, 294, + 288, 635, 636, 289, 637, 291, 638, 639, 293, 294, 295, 296, 297, 298, 299, 300, 640, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 641, 642, 643, - 325, 326, 327, 644, 0, 329, 330, 646, 332, 0, - 648, 334, 649, 336, 337, 338, 0, 339, 340, 0, - 0, 341, 342, 343, 0, 0, 344, 345, 655, 656, + 325, 326, 327, 644, 645, 329, 330, 646, 332, 647, + 648, 334, 649, 336, 337, 338, 650, 339, 340, 651, + 652, 341, 342, 343, 653, 654, 344, 345, 655, 656, 348, 657, 658, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, - 663, 664, 366, 367, 665, 369, 370, 371, 0, 372, - 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, - 382, 668, 384, 385, 386, 387, 0, 388, 389, 390, + 358, 359, 360, 361, 659, 660, 661, 662, 362, 363, + 663, 664, 366, 367, 665, 369, 370, 371, 666, 372, + 373, 374, 375, 376, 377, 667, 378, 379, 380, 381, + 382, 668, 384, 385, 386, 387, 669, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, - 0, 401, 402, 671, 404, 405, 406, 672, 408, 409, + 670, 401, 402, 671, 404, 405, 406, 672, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, - 420, 0, 674, 421, 422, 423, 424, 425, 426, 675, - 428, 429, 0, 677, 431, 432, 678, 434, 0, 435, + 420, 673, 674, 421, 422, 423, 424, 425, 426, 675, + 428, 429, 676, 677, 431, 432, 678, 434, 679, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, - 446, 680, 448, 681, 0, 0, 450, 451, 0, 452, - 685, 454, 455, 456, 457, 458, 0, 459, 687, 688, - 0, 0, 462, 463, 691, 465, 692, 0, 467, 468, - 694, 470, 471, 472, 473, 474, 0, 0, 475, 476, - 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, - 485, 486, 699, 700, 489, 0, 490, 702, 492, 493, - 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, + 446, 680, 448, 681, 682, 683, 450, 451, 684, 452, + 685, 454, 455, 456, 457, 458, 686, 459, 687, 688, + 689, 690, 462, 463, 691, 465, 692, 693, 467, 468, + 694, 470, 471, 472, 473, 474, 695, 696, 475, 476, + 477, 697, 478, 479, 480, 481, 698, 482, 483, 484, + 485, 486, 699, 700, 489, 701, 490, 702, 492, 493, + 494, 495, 496, 497, 498, 703, 704, 499, 705, 706, 500, 501, 502, 503, 504, 505, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 517, 518, 519, - 520, 117, 0, 0, 0, 0, 0, 0, 0, 0, + 520, 560, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, - 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, - 129, 130, 131, 0, 132, 133, 134, 135, 136, 137, - 138, 139, 140, 141, 142, 143, 0, 144, 145, 146, - 147, 148, 149, 0, 790, 150, 151, 152, 153, 154, - 155, 156, 0, 157, 158, 159, 160, 791, 0, 792, - 0, 163, 164, 165, 166, 167, 168, 169, 170, 171, - 172, 0, 173, 174, 175, 176, 177, 178, 0, 179, + 118, 119, 120, 121, 122, 123, 124, 125, 561, 126, + 127, 128, 562, 563, 564, 565, 566, 567, 568, 569, + 570, 130, 131, 571, 132, 133, 134, 572, 136, 137, + 138, 573, 574, 575, 576, 577, 578, 144, 145, 146, + 147, 148, 149, 579, 580, 150, 151, 152, 153, 581, + 582, 156, 583, 157, 158, 159, 160, 584, 585, 586, + 587, 588, 164, 165, 166, 167, 168, 589, 170, 171, + 172, 590, 173, 174, 175, 176, 177, 178, 591, 592, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, - 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, - 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, - 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 227, 793, 0, 229, - 0, 230, 231, 232, 233, 0, 234, 0, 235, 236, - 0, 237, 238, 239, 240, 241, 242, 0, 243, 0, - 244, 245, 246, 247, 0, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, - 262, 263, 264, 265, 266, 0, 267, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, - 0, 0, 289, 290, 291, 292, 0, 293, 294, 295, - 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 594, 191, 192, 595, 194, 596, 195, 597, 196, 197, + 198, 199, 200, 201, 598, 599, 202, 203, 204, 205, + 600, 601, 206, 207, 208, 209, 210, 602, 211, 212, + 213, 603, 214, 215, 216, 604, 217, 218, 219, 220, + 605, 222, 223, 224, 225, 226, 227, 606, 607, 229, + 608, 230, 231, 609, 233, 610, 234, 611, 235, 612, + 613, 614, 238, 239, 615, 616, 242, 617, 243, 618, + 619, 620, 246, 247, 621, 248, 249, 250, 251, 252, + 253, 254, 622, 256, 257, 258, 259, 623, 260, 261, + 262, 263, 264, 265, 266, 624, 267, 625, 626, 270, + 271, 272, 273, 274, 627, 628, 629, 630, 631, 278, + 632, 633, 281, 634, 283, 284, 285, 286, 287, 288, + 635, 636, 289, 637, 291, 638, 639, 293, 294, 295, + 296, 297, 298, 299, 300, 640, 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, 329, 330, 331, 332, 0, 795, - 334, 335, 336, 337, 338, 0, 339, 340, 0, 0, - 341, 342, 343, 0, 0, 344, 345, 346, 347, 348, - 349, 797, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, 361, 0, 0, 0, 0, 362, 363, 798, - 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, - 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, - 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 316, 317, 318, 319, 320, 321, 641, 642, 643, 325, + 326, 327, 644, 645, 329, 330, 646, 332, 647, 648, + 334, 649, 336, 337, 338, 650, 339, 340, 651, 652, + 341, 342, 343, 653, 654, 344, 345, 655, 656, 348, + 657, 658, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 360, 361, 659, 660, 661, 662, 362, 363, 663, + 664, 366, 367, 665, 369, 370, 371, 666, 372, 373, + 374, 375, 376, 377, 667, 378, 379, 380, 381, 382, + 668, 384, 385, 386, 387, 669, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 397, 398, 399, 400, 670, + 401, 402, 671, 404, 405, 406, 672, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, - 429, 0, 430, 431, 432, 433, 434, 0, 435, 436, + 673, 674, 421, 422, 423, 424, 425, 426, 675, 428, + 429, 676, 677, 431, 432, 678, 434, 679, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - 447, 448, 800, 0, 0, 450, 451, 0, 452, 453, - 454, 455, 456, 457, 458, 0, 459, 460, 461, 0, - 0, 462, 463, 801, 465, 802, 0, 467, 468, 803, - 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, - 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, - 486, 487, 488, 489, 0, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, - 117, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 680, 448, 681, 682, 683, 450, 451, 684, 452, 685, + 454, 455, 456, 457, 458, 686, 459, 687, 688, 689, + 690, 462, 463, 691, 465, 692, 693, 467, 468, 694, + 470, 471, 472, 473, 474, 695, 696, 475, 476, 477, + 697, 478, 479, 480, 481, 698, 482, 483, 484, 485, + 486, 699, 700, 489, 701, 490, 702, 492, 493, 494, + 495, 496, 497, 498, 703, 704, 499, 705, 706, 500, + 501, 502, 503, 504, 505, 707, 708, 709, 710, 711, + 712, 713, 714, 715, 716, 717, 517, 518, 519, 520, + 560, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, - 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, - 128, 0, 0, 0, 0, 0, 0, 0, 0, 129, - 130, 131, 0, 132, 133, 134, 135, 136, 137, 138, - 139, 140, 141, 142, 143, 0, 144, 145, 146, 147, - 148, 149, 0, 0, 150, 151, 152, 153, 154, 155, - 156, 0, 157, 158, 159, 160, 161, 0, 162, 0, - 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, - 0, 173, 174, 175, 176, 177, 178, 0, 179, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, - 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, - 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, - 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, - 0, 214, 215, 216, 0, 217, 218, 219, 220, 221, - 222, 223, 224, 225, 226, 227, 228, 0, 229, 0, - 230, 231, 232, 233, 0, 234, 0, 235, 236, 0, - 237, 238, 239, 240, 241, 242, 0, 243, 0, 244, - 245, 246, 247, 0, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 0, 260, 261, 262, - 263, 264, 265, 266, 0, 267, 268, 269, 270, 271, - 272, 273, 274, 275, 276, 0, 277, 0, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 0, - 0, 289, 290, 291, 292, 0, 293, 294, 295, 296, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, + 119, 120, 121, 2286, 123, 124, 125, 561, 126, 127, + 128, 562, 563, 564, 565, 566, 567, 568, 569, 570, + 130, 131, 571, 132, 133, 134, 572, 136, 137, 138, + 573, 574, 575, 576, 577, 578, 144, 145, 146, 147, + 148, 149, 579, 580, 150, 151, 152, 153, 581, 582, + 156, 583, 157, 158, 159, 160, 584, 585, 586, 587, + 588, 164, 165, 166, 167, 168, 589, 170, 171, 172, + 590, 173, 174, 175, 176, 177, 178, 591, 592, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 594, + 191, 192, 595, 194, 596, 195, 597, 196, 197, 198, + 199, 200, 201, 598, 599, 202, 203, 204, 205, 600, + 601, 206, 207, 208, 2287, 210, 602, 211, 212, 213, + 603, 214, 215, 216, 604, 217, 218, 219, 220, 605, + 222, 223, 224, 225, 226, 227, 606, 607, 229, 608, + 230, 231, 609, 233, 610, 234, 611, 235, 612, 613, + 614, 238, 239, 615, 616, 242, 617, 243, 618, 619, + 620, 246, 247, 621, 248, 249, 250, 251, 252, 253, + 254, 622, 256, 257, 258, 259, 623, 260, 261, 262, + 263, 264, 265, 266, 624, 267, 625, 626, 270, 271, + 272, 273, 274, 627, 628, 629, 630, 631, 278, 632, + 633, 281, 634, 283, 284, 285, 286, 287, 288, 635, + 636, 289, 637, 291, 638, 639, 293, 294, 295, 296, + 297, 298, 299, 300, 640, 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, 329, 330, 331, 332, 0, 333, 334, - 335, 336, 337, 338, 0, 339, 340, 0, 0, 341, - 342, 343, 0, 0, 344, 345, 346, 347, 348, 349, - 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, 361, 0, 0, 0, 0, 362, 363, 364, 365, - 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, - 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, - 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, - 0, 421, 422, 423, 424, 425, 426, 427, 428, 429, - 0, 430, 431, 432, 433, 434, 0, 435, 436, 437, - 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, - 448, 449, 0, 0, 450, 451, 0, 452, 453, 454, - 455, 456, 457, 458, 0, 459, 460, 461, 0, 0, - 462, 463, 464, 465, 466, 0, 467, 468, 469, 470, - 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, - 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, - 487, 488, 489, 0, 490, 491, 492, 493, 494, 495, - 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, - 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, - 512, 513, 514, 515, 516, 517, 518, 519, 520, 528, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 317, 318, 319, 320, 321, 641, 642, 643, 325, 326, + 327, 644, 645, 329, 330, 646, 332, 647, 648, 334, + 649, 336, 337, 338, 650, 339, 340, 651, 652, 341, + 342, 343, 653, 654, 344, 345, 655, 656, 348, 657, + 658, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, 361, 659, 660, 661, 662, 362, 363, 663, 664, + 366, 367, 665, 369, 370, 371, 666, 372, 373, 374, + 375, 376, 377, 667, 378, 379, 380, 381, 382, 668, + 384, 385, 386, 387, 669, 388, 389, 390, 391, 392, + 393, 394, 395, 396, 397, 398, 399, 400, 670, 401, + 402, 671, 404, 405, 406, 672, 408, 409, 410, 411, + 412, 413, 414, 415, 416, 417, 418, 419, 420, 673, + 674, 421, 422, 423, 424, 425, 2288, 675, 428, 429, + 676, 677, 431, 432, 678, 434, 679, 435, 436, 437, + 438, 439, 440, 441, 442, 443, 444, 445, 446, 680, + 448, 681, 682, 683, 450, 451, 684, 452, 685, 454, + 455, 456, 457, 458, 686, 459, 687, 688, 689, 690, + 462, 463, 691, 465, 692, 693, 467, 468, 694, 470, + 471, 472, 473, 474, 695, 696, 475, 476, 477, 697, + 478, 479, 480, 481, 698, 482, 483, 484, 485, 486, + 699, 700, 489, 701, 490, 702, 492, 493, 494, 495, + 496, 497, 498, 703, 704, 499, 705, 706, 500, 501, + 502, 503, 504, 505, 707, 708, 709, 710, 711, 712, + 713, 714, 715, 716, 717, 517, 518, 519, 520, 974, + 0, 821, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, - 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, - 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, - 149, 0, 0, 150, 151, 152, 153, 154, 155, 156, - 1770, 157, 158, 159, 160, 161, 0, 0, 1771, 163, - 164, 165, 166, 167, 168, 0, 170, 171, 172, 1772, - 173, 174, 175, 176, 177, 178, 0, 0, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, - 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, + 0, 0, 0, 565, 0, 0, 0, 0, 570, 130, + 131, 0, 132, 133, 134, 572, 136, 137, 138, 573, + 574, 575, 576, 577, 0, 144, 145, 146, 147, 148, + 149, 0, 0, 150, 151, 152, 153, 581, 582, 156, + 0, 157, 158, 159, 160, 584, 0, 586, 0, 588, + 164, 165, 166, 167, 168, 589, 170, 171, 172, 0, + 173, 174, 175, 176, 177, 178, 0, 592, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 594, 191, + 192, 595, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, - 214, 215, 216, 0, 217, 218, 219, 220, 221, 222, - 223, 224, 225, 226, 227, 228, 0, 229, 0, 230, - 231, 232, 233, 0, 234, 1773, 235, 0, 0, 0, - 238, 239, 529, 0, 242, 0, 243, 0, 244, 245, - 246, 247, 0, 248, 249, 250, 251, 252, 1774, 254, - 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, - 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, - 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, - 281, 0, 283, 284, 285, 286, 287, 288, 0, 0, - 289, 0, 291, 0, 0, 293, 294, 295, 296, 297, - 298, 299, 300, 530, 302, 303, 304, 305, 306, 307, + 214, 215, 216, 0, 217, 218, 219, 220, 605, 222, + 223, 224, 225, 226, 227, 606, 1365, 229, 0, 230, + 231, 609, 233, 0, 234, 0, 235, 612, 0, 614, + 238, 239, 615, 616, 242, 0, 243, 0, 619, 620, + 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, + 622, 256, 257, 258, 259, 0, 260, 261, 262, 263, + 264, 265, 266, 0, 267, 625, 626, 270, 271, 272, + 273, 274, 627, 628, 0, 630, 0, 278, 632, 633, + 281, 634, 283, 284, 285, 286, 287, 288, 0, 0, + 289, 637, 291, 638, 0, 293, 294, 295, 296, 297, + 298, 299, 300, 640, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, 321, 322, 0, 324, 325, 326, 327, - 328, 0, 329, 330, 0, 332, 0, 333, 334, 335, - 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, - 343, 0, 0, 344, 345, 346, 0, 348, 0, 350, + 318, 319, 320, 321, 641, 642, 643, 325, 326, 327, + 644, 0, 329, 330, 646, 332, 0, 648, 334, 649, + 336, 337, 338, 0, 339, 340, 1366, 0, 341, 342, + 343, 0, 0, 344, 345, 655, 656, 348, 657, 658, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - 361, 0, 0, 0, 0, 362, 363, 364, 0, 366, - 367, 368, 369, 370, 371, 1775, 372, 373, 374, 375, - 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, + 361, 0, 0, 0, 0, 362, 363, 663, 664, 366, + 367, 665, 369, 370, 371, 0, 372, 373, 374, 375, + 376, 377, 0, 378, 379, 380, 381, 382, 668, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, - 0, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, - 421, 422, 423, 424, 425, 426, 427, 428, 429, 0, - 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 445, 446, 531, 448, - 449, 0, 0, 450, 451, 0, 452, 0, 454, 455, - 456, 457, 458, 0, 459, 460, 461, 0, 0, 462, - 463, 464, 465, 466, 0, 467, 468, 469, 470, 471, - 472, 473, 474, 0, 1776, 475, 476, 477, 0, 478, - 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, - 488, 489, 0, 490, 0, 492, 493, 494, 495, 496, + 671, 404, 405, 406, 672, 408, 409, 410, 411, 412, + 413, 414, 415, 416, 417, 418, 419, 420, 0, 674, + 421, 422, 423, 424, 425, 426, 675, 428, 429, 0, + 677, 431, 432, 678, 434, 0, 435, 436, 437, 438, + 439, 440, 441, 442, 443, 444, 445, 446, 680, 448, + 681, 0, 0, 450, 451, 0, 452, 685, 454, 455, + 456, 457, 458, 0, 459, 687, 688, 0, 0, 462, + 463, 691, 465, 692, 1367, 467, 468, 694, 470, 471, + 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, + 479, 480, 481, 0, 482, 483, 484, 485, 486, 699, + 700, 489, 0, 490, 702, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 516, 517, 518, 519, 520, 528, 0, + 503, 504, 505, 707, 708, 709, 710, 711, 712, 713, + 714, 715, 716, 717, 517, 518, 519, 520, 974, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, - 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, - 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, - 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, - 0, 0, 150, 151, 152, 153, 154, 155, 156, 1770, - 157, 158, 159, 160, 161, 0, 0, 0, 163, 164, - 165, 166, 167, 168, 0, 170, 171, 172, 1772, 173, - 174, 175, 176, 177, 178, 0, 0, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, + 121, 122, 123, 124, 125, 0, 126, 127, 128, 3, + 4, 0, 565, 0, 0, 0, 0, 570, 130, 131, + 0, 132, 133, 134, 572, 136, 137, 138, 573, 574, + 575, 576, 577, 0, 144, 145, 146, 147, 148, 149, + 0, 0, 150, 151, 152, 153, 581, 582, 156, 0, + 157, 158, 159, 160, 584, 0, 586, 0, 588, 164, + 165, 166, 167, 168, 589, 170, 171, 172, 0, 173, + 174, 175, 176, 177, 178, 0, 592, 180, 181, 182, + 183, 184, 185, 186, 187, 188, 189, 594, 191, 192, + 595, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, - 215, 216, 0, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, - 232, 233, 0, 234, 1773, 235, 0, 0, 0, 238, - 239, 529, 0, 242, 0, 243, 0, 244, 245, 246, - 247, 0, 248, 249, 250, 251, 252, 253, 254, 0, + 215, 216, 0, 217, 218, 219, 220, 605, 222, 223, + 224, 225, 226, 227, 606, 0, 229, 0, 230, 231, + 609, 233, 0, 234, 0, 235, 612, 0, 614, 238, + 239, 615, 616, 242, 0, 243, 0, 619, 620, 246, + 247, 0, 248, 249, 250, 251, 252, 253, 254, 622, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, - 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, - 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, - 0, 283, 284, 285, 286, 287, 288, 0, 0, 289, - 0, 291, 2369, 0, 293, 294, 295, 296, 297, 298, - 299, 300, 530, 302, 303, 304, 305, 306, 307, 308, + 265, 266, 0, 267, 625, 626, 270, 271, 272, 273, + 274, 627, 628, 0, 630, 0, 278, 632, 633, 281, + 634, 283, 284, 285, 286, 287, 288, 0, 0, 289, + 637, 291, 638, 0, 293, 294, 295, 296, 297, 298, + 299, 300, 640, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 322, 0, 324, 325, 326, 327, 328, - 0, 329, 330, 0, 332, 0, 333, 334, 335, 336, + 319, 320, 321, 641, 642, 643, 325, 326, 327, 644, + 0, 329, 330, 646, 332, 0, 648, 334, 649, 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, 343, - 0, 0, 344, 345, 346, 0, 348, 0, 350, 351, + 0, 0, 344, 345, 655, 656, 348, 657, 658, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, - 0, 0, 0, 0, 362, 363, 364, 0, 366, 367, - 368, 369, 370, 371, 1775, 372, 373, 374, 375, 376, - 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, + 0, 0, 0, 0, 362, 363, 663, 664, 366, 367, + 665, 369, 370, 371, 0, 372, 373, 374, 375, 376, + 377, 0, 378, 379, 380, 381, 382, 668, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 397, 398, 399, 400, 0, 401, 402, 0, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, - 422, 423, 424, 425, 426, 427, 428, 429, 0, 0, - 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, - 440, 441, 442, 443, 444, 445, 446, 531, 448, 449, - 0, 0, 450, 451, 0, 452, 0, 454, 455, 456, - 457, 458, 0, 459, 460, 461, 0, 0, 462, 463, - 464, 465, 466, 0, 467, 468, 469, 470, 471, 472, - 473, 474, 0, 1776, 475, 476, 477, 0, 478, 479, - 480, 481, 0, 482, 483, 484, 485, 486, 487, 488, - 489, 0, 490, 0, 492, 493, 494, 495, 496, 497, + 395, 396, 397, 398, 399, 400, 0, 401, 402, 671, + 404, 405, 406, 672, 408, 409, 410, 411, 412, 413, + 414, 415, 416, 417, 418, 419, 420, 0, 674, 421, + 422, 423, 424, 425, 426, 675, 428, 429, 0, 677, + 431, 432, 678, 434, 0, 435, 436, 437, 438, 439, + 440, 441, 442, 443, 444, 445, 446, 680, 448, 681, + 0, 0, 450, 451, 0, 452, 685, 454, 455, 456, + 457, 458, 0, 459, 687, 688, 0, 0, 462, 463, + 691, 465, 692, 0, 467, 468, 694, 470, 471, 472, + 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, + 480, 481, 0, 482, 483, 484, 485, 486, 699, 700, + 489, 0, 490, 702, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, - 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, - 514, 515, 516, 517, 518, 519, 520, 528, 0, 554, + 504, 505, 707, 708, 709, 710, 711, 712, 713, 714, + 715, 716, 717, 517, 518, 519, 520, 117, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, - 122, 123, 124, 125, 0, 126, 127, 128, 3, 4, - 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, - 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, + 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, + 0, 0, 0, 0, 0, 0, 129, 130, 131, 0, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, - 0, 150, 151, 152, 153, 154, 155, 156, 0, 157, - 158, 159, 160, 161, 0, 0, 0, 163, 164, 165, - 166, 167, 168, 0, 170, 171, 172, 0, 173, 174, - 175, 176, 177, 178, 0, 0, 180, 181, 182, 183, + 790, 150, 151, 152, 153, 154, 155, 156, 0, 157, + 158, 159, 160, 791, 0, 792, 0, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 0, 173, 174, + 175, 176, 177, 178, 0, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, - 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, - 529, 0, 242, 0, 243, 0, 244, 245, 246, 247, - 0, 248, 249, 250, 251, 252, 253, 254, 0, 256, + 225, 226, 227, 793, 0, 229, 0, 230, 231, 232, + 233, 0, 234, 0, 235, 236, 0, 237, 238, 239, + 240, 241, 242, 0, 243, 0, 244, 245, 246, 247, + 0, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, - 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, - 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, - 283, 284, 285, 286, 287, 288, 0, 0, 289, 0, - 291, 0, 0, 293, 294, 295, 296, 297, 298, 299, - 300, 530, 302, 303, 304, 305, 306, 307, 308, 309, + 266, 0, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 0, 277, 0, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 0, 0, 289, 290, + 291, 292, 0, 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, 0, 324, 325, 326, 327, 328, 0, - 329, 330, 0, 332, 0, 333, 334, 335, 336, 337, + 320, 321, 322, 323, 324, 325, 326, 327, 328, 0, + 329, 330, 331, 332, 0, 795, 334, 335, 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, 343, 0, - 0, 344, 345, 346, 0, 348, 0, 350, 351, 352, + 0, 344, 345, 346, 347, 348, 349, 797, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, - 0, 0, 0, 362, 363, 364, 0, 366, 367, 368, + 0, 0, 0, 362, 363, 798, 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, - 396, 397, 398, 399, 400, 0, 401, 402, 0, 404, + 396, 397, 398, 399, 400, 0, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, - 423, 424, 425, 426, 427, 428, 429, 0, 0, 431, + 423, 424, 425, 426, 427, 428, 429, 0, 430, 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, - 441, 442, 443, 444, 445, 446, 531, 448, 449, 0, - 0, 450, 451, 0, 452, 0, 454, 455, 456, 457, - 458, 0, 459, 460, 461, 0, 0, 462, 463, 464, - 465, 466, 0, 467, 468, 469, 470, 471, 472, 473, + 441, 442, 443, 444, 445, 446, 447, 448, 800, 0, + 0, 450, 451, 0, 452, 453, 454, 455, 456, 457, + 458, 0, 459, 460, 461, 0, 0, 462, 463, 801, + 465, 802, 0, 467, 468, 803, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, 488, 489, - 0, 490, 0, 492, 493, 494, 495, 496, 497, 498, + 0, 490, 491, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, - 515, 516, 517, 518, 519, 520, 528, 0, 554, 0, + 515, 516, 517, 518, 519, 520, 117, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 555, 126, 127, 128, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, - 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, + 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, + 0, 0, 0, 0, 0, 129, 130, 131, 0, 132, + 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, 154, 155, 156, 0, 157, 158, - 159, 160, 161, 0, 0, 0, 163, 164, 165, 166, - 167, 168, 0, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 0, 180, 181, 182, 183, 184, + 159, 160, 161, 0, 162, 0, 163, 164, 165, 166, + 167, 168, 169, 170, 171, 172, 0, 173, 174, 175, + 176, 177, 178, 0, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, - 0, 234, 0, 235, 0, 0, 0, 238, 239, 529, - 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 0, 256, 257, + 0, 234, 0, 235, 236, 0, 237, 238, 239, 240, + 241, 242, 0, 243, 0, 244, 245, 246, 247, 0, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, - 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 0, 291, - 0, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 530, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 0, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 0, 277, 0, 278, 279, 280, 281, 282, 283, + 284, 285, 286, 287, 288, 0, 0, 289, 290, 291, + 292, 0, 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, 0, 324, 325, 326, 327, 328, 0, 329, - 330, 0, 332, 0, 333, 334, 335, 336, 337, 338, + 321, 322, 323, 324, 325, 326, 327, 328, 0, 329, + 330, 331, 332, 0, 333, 334, 335, 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, 343, 0, 0, - 344, 345, 346, 0, 348, 0, 350, 351, 352, 353, + 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 364, 0, 366, 367, 368, 556, + 0, 0, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 0, 404, 405, + 397, 398, 399, 400, 0, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 0, 431, 432, + 424, 425, 426, 427, 428, 429, 0, 430, 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 531, 448, 449, 0, 0, - 450, 451, 0, 452, 0, 454, 455, 456, 457, 458, + 442, 443, 444, 445, 446, 447, 448, 449, 0, 0, + 450, 451, 0, 452, 453, 454, 455, 456, 457, 458, 0, 459, 460, 461, 0, 0, 462, 463, 464, 465, 466, 0, 467, 468, 469, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, 488, 489, 0, - 490, 0, 492, 493, 494, 495, 496, 497, 498, 0, + 490, 491, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 520, 528, 0, 554, 0, 0, + 516, 517, 518, 519, 520, 528, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, - 151, 152, 153, 154, 155, 156, 0, 157, 158, 159, - 160, 161, 0, 0, 0, 163, 164, 165, 166, 167, - 168, 0, 170, 171, 172, 0, 173, 174, 175, 176, + 151, 152, 153, 154, 155, 156, 1770, 157, 158, 159, + 160, 161, 0, 0, 1771, 163, 164, 165, 166, 167, + 168, 0, 170, 171, 172, 1772, 173, 174, 175, 176, 177, 178, 0, 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, @@ -9859,9 +9652,9 @@ static const yytype_int16 yytable[] = 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, - 234, 0, 235, 0, 0, 0, 238, 239, 529, 0, + 234, 1773, 235, 0, 0, 0, 238, 239, 529, 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, - 249, 250, 251, 252, 253, 254, 0, 256, 257, 258, + 249, 250, 251, 252, 1774, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, @@ -9871,11 +9664,11 @@ static const yytype_int16 yytable[] = 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 0, 324, 325, 326, 327, 328, 0, 329, 330, 0, 332, 0, 333, 334, 335, 336, 337, 338, 0, - 339, 340, 0, 796, 341, 342, 343, 0, 0, 344, + 339, 340, 0, 0, 341, 342, 343, 0, 0, 344, 345, 346, 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, 364, 0, 366, 367, 368, 369, 370, - 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, + 371, 1775, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, 0, 404, 405, 406, @@ -9887,21 +9680,21 @@ static const yytype_int16 yytable[] = 451, 0, 452, 0, 454, 455, 456, 457, 458, 0, 459, 460, 461, 0, 0, 462, 463, 464, 465, 466, 0, 467, 468, 469, 470, 471, 472, 473, 474, 0, - 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, + 1776, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, 488, 489, 0, 490, 0, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, - 517, 518, 519, 520, 528, 0, 554, 0, 0, 0, + 517, 518, 519, 520, 528, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, - 152, 153, 154, 155, 156, 0, 157, 158, 159, 160, + 152, 153, 154, 155, 156, 1770, 157, 158, 159, 160, 161, 0, 0, 0, 163, 164, 165, 166, 167, 168, - 0, 170, 171, 172, 0, 173, 174, 175, 176, 177, + 0, 170, 171, 172, 1772, 173, 174, 175, 176, 177, 178, 0, 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, @@ -9909,23 +9702,23 @@ static const yytype_int16 yytable[] = 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, - 0, 235, 0, 0, 0, 238, 239, 529, 0, 242, + 1773, 235, 0, 0, 0, 238, 239, 529, 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, - 250, 251, 252, 904, 254, 0, 256, 257, 258, 259, + 250, 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, - 286, 287, 288, 0, 0, 289, 0, 291, 0, 0, + 286, 287, 288, 0, 0, 289, 0, 291, 2372, 0, 293, 294, 295, 296, 297, 298, 299, 300, 530, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 0, 324, 325, 326, 327, 328, 0, 329, 330, 0, 332, 0, 333, 334, 335, 336, 337, 338, 0, 339, - 340, 0, 796, 341, 342, 343, 0, 0, 344, 345, + 340, 0, 0, 341, 342, 343, 0, 0, 344, 345, 346, 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, 364, 0, 366, 367, 368, 369, 370, 371, - 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, + 1775, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, 0, 404, 405, 406, 407, @@ -9936,7 +9729,7 @@ static const yytype_int16 yytable[] = 444, 445, 446, 531, 448, 449, 0, 0, 450, 451, 0, 452, 0, 454, 455, 456, 457, 458, 0, 459, 460, 461, 0, 0, 462, 463, 464, 465, 466, 0, - 467, 468, 469, 470, 471, 472, 473, 474, 0, 0, + 467, 468, 469, 470, 471, 472, 473, 474, 0, 1776, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, 488, 489, 0, 490, 0, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, @@ -9945,7 +9738,7 @@ static const yytype_int16 yytable[] = 518, 519, 520, 528, 0, 554, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, - 948, 126, 127, 128, 0, 0, 0, 0, 0, 0, + 0, 126, 127, 128, 3, 4, 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, @@ -9994,7 +9787,7 @@ static const yytype_int16 yytable[] = 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 528, 0, 554, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, + 0, 118, 119, 120, 121, 122, 123, 124, 125, 555, 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, @@ -10007,7 +9800,7 @@ static const yytype_int16 yytable[] = 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 1184, 227, 228, 0, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, 529, 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, 251, @@ -10021,10 +9814,10 @@ static const yytype_int16 yytable[] = 315, 316, 317, 318, 319, 320, 321, 322, 0, 324, 325, 326, 327, 328, 0, 329, 330, 0, 332, 0, 333, 334, 335, 336, 337, 338, 0, 339, 340, 0, - 796, 341, 342, 343, 0, 0, 344, 345, 346, 0, + 0, 341, 342, 343, 0, 0, 344, 345, 346, 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, - 364, 0, 366, 367, 368, 369, 370, 371, 0, 372, + 364, 0, 366, 367, 368, 556, 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, @@ -10059,18 +9852,18 @@ static const yytype_int16 yytable[] = 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, - 0, 0, 238, 239, 529, 0, 1990, 0, 243, 0, + 0, 0, 238, 239, 529, 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, 287, 288, - 0, 0, 289, 0, 291, 0, 0, 293, 294, 1991, + 0, 0, 289, 0, 291, 0, 0, 293, 294, 295, 296, 297, 298, 299, 300, 530, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 0, 324, 325, 326, 327, 328, 0, 329, 330, 0, 332, 0, 333, - 334, 335, 336, 337, 338, 0, 339, 340, 0, 0, + 334, 335, 336, 337, 338, 0, 339, 340, 0, 796, 341, 342, 343, 0, 0, 344, 345, 346, 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, 364, @@ -10083,10 +9876,10 @@ static const yytype_int16 yytable[] = 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, 429, 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - 531, 448, 449, 0, 0, 450, 451, 1992, 452, 0, - 454, 1993, 456, 1994, 458, 0, 459, 460, 461, 0, + 531, 448, 449, 0, 0, 450, 451, 0, 452, 0, + 454, 455, 456, 457, 458, 0, 459, 460, 461, 0, 0, 462, 463, 464, 465, 466, 0, 467, 468, 469, - 470, 471, 472, 473, 474, 0, 0, 475, 476, 1995, + 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, 488, 489, 0, 490, 0, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, @@ -10110,7 +9903,7 @@ static const yytype_int16 yytable[] = 222, 223, 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, 529, 0, 242, 0, 243, 0, 244, - 245, 246, 247, 0, 248, 249, 250, 251, 252, 253, + 245, 246, 247, 0, 248, 249, 250, 251, 252, 904, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, @@ -10120,7 +9913,7 @@ static const yytype_int16 yytable[] = 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 0, 324, 325, 326, 327, 328, 0, 329, 330, 0, 332, 0, 333, 334, - 335, 336, 337, 338, 0, 339, 340, 0, 0, 341, + 335, 336, 337, 338, 0, 339, 340, 0, 796, 341, 342, 343, 0, 0, 344, 345, 346, 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, 364, 0, @@ -10142,9 +9935,9 @@ static const yytype_int16 yytable[] = 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 528, - 0, 821, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 554, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, - 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, + 120, 121, 122, 123, 124, 125, 948, 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, @@ -10192,9 +9985,9 @@ static const yytype_int16 yytable[] = 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 528, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 554, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, - 121, 122, 123, 124, 125, 827, 126, 127, 128, 0, + 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, @@ -10207,20 +10000,20 @@ static const yytype_int16 yytable[] = 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, + 224, 225, 1184, 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, - 239, 529, 0, 828, 0, 243, 0, 244, 245, 246, + 239, 529, 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, 287, 288, 0, 0, 289, - 0, 291, 0, 0, 293, 294, 829, 296, 297, 298, + 0, 291, 0, 0, 293, 294, 295, 296, 297, 298, 299, 300, 530, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 0, 324, 325, 326, 327, 328, 0, 329, 330, 0, 332, 0, 333, 334, 335, 336, - 337, 338, 0, 339, 340, 0, 0, 341, 342, 343, + 337, 338, 0, 339, 340, 0, 796, 341, 342, 343, 0, 0, 344, 345, 346, 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, 364, 0, 366, 367, @@ -10230,15 +10023,15 @@ static const yytype_int16 yytable[] = 395, 396, 397, 398, 399, 400, 0, 401, 402, 0, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, - 422, 423, 424, 830, 426, 427, 428, 429, 0, 0, + 422, 423, 424, 425, 426, 427, 428, 429, 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 531, 448, 449, 0, 0, 450, 451, 0, 452, 0, 454, 455, 456, - 457, 458, 0, 459, 831, 461, 0, 0, 832, 463, + 457, 458, 0, 459, 460, 461, 0, 0, 462, 463, 464, 465, 466, 0, 467, 468, 469, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, 488, - 833, 0, 490, 0, 492, 493, 494, 495, 496, 497, + 489, 0, 490, 0, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 528, 0, 554, @@ -10259,13 +10052,13 @@ static const yytype_int16 yytable[] = 216, 0, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, - 529, 0, 242, 0, 243, 0, 244, 245, 246, 247, + 529, 0, 1992, 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, 287, 288, 0, 0, 289, 0, - 291, 0, 0, 293, 294, 295, 296, 297, 298, 299, + 291, 0, 0, 293, 294, 1993, 296, 297, 298, 299, 300, 530, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 0, 324, 325, 326, 327, 328, 0, @@ -10275,7 +10068,7 @@ static const yytype_int16 yytable[] = 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, 364, 0, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, - 0, 378, 379, 380, 381, 382, 383, 384, 385, 866, + 0, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, 0, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, @@ -10283,10 +10076,10 @@ static const yytype_int16 yytable[] = 423, 424, 425, 426, 427, 428, 429, 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 531, 448, 449, 0, - 0, 450, 451, 0, 452, 0, 454, 455, 456, 457, + 0, 450, 451, 1994, 452, 0, 454, 1995, 456, 1996, 458, 0, 459, 460, 461, 0, 0, 462, 463, 464, 465, 466, 0, 467, 468, 469, 470, 471, 472, 473, - 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, + 474, 0, 0, 475, 476, 1997, 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, 488, 489, 0, 490, 0, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, @@ -10310,7 +10103,7 @@ static const yytype_int16 yytable[] = 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, 529, 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, - 248, 249, 250, 251, 252, 899, 254, 0, 256, 257, + 248, 249, 250, 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, @@ -10341,7 +10134,7 @@ static const yytype_int16 yytable[] = 490, 0, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 520, 528, 0, 554, 0, 0, + 516, 517, 518, 519, 520, 528, 0, 821, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, @@ -10360,7 +10153,7 @@ static const yytype_int16 yytable[] = 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, 529, 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, - 249, 250, 251, 252, 902, 254, 0, 256, 257, 258, + 249, 250, 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, @@ -10391,10 +10184,10 @@ static const yytype_int16 yytable[] = 0, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, - 517, 518, 519, 520, 528, 0, 554, 0, 0, 0, + 517, 518, 519, 520, 528, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, - 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, + 125, 827, 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, @@ -10408,14 +10201,14 @@ static const yytype_int16 yytable[] = 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, - 0, 235, 0, 0, 0, 238, 239, 529, 0, 242, + 0, 235, 0, 0, 0, 238, 239, 529, 0, 828, 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, - 250, 251, 252, 906, 254, 0, 256, 257, 258, 259, + 250, 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, 287, 288, 0, 0, 289, 0, 291, 0, 0, - 293, 294, 295, 296, 297, 298, 299, 300, 530, 302, + 293, 294, 829, 296, 297, 298, 299, 300, 530, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 0, 324, 325, 326, 327, 328, 0, 329, 330, 0, @@ -10429,15 +10222,15 @@ static const yytype_int16 yytable[] = 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, 0, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, + 418, 419, 420, 0, 0, 421, 422, 423, 424, 830, 426, 427, 428, 429, 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 531, 448, 449, 0, 0, 450, 451, 0, 452, 0, 454, 455, 456, 457, 458, 0, 459, - 460, 461, 0, 0, 462, 463, 464, 465, 466, 0, + 831, 461, 0, 0, 832, 463, 464, 465, 466, 0, 467, 468, 469, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, - 483, 484, 485, 486, 487, 488, 489, 0, 490, 0, + 483, 484, 485, 486, 487, 488, 833, 0, 490, 0, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, @@ -10460,7 +10253,7 @@ static const yytype_int16 yytable[] = 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, 529, 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, - 251, 252, 936, 254, 0, 256, 257, 258, 259, 0, + 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, @@ -10475,7 +10268,7 @@ static const yytype_int16 yytable[] = 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, 364, 0, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, - 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, + 381, 382, 383, 384, 385, 866, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, 0, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, @@ -10510,7 +10303,7 @@ static const yytype_int16 yytable[] = 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, 529, 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, 251, - 252, 964, 254, 0, 256, 257, 258, 259, 0, 260, + 252, 899, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, 287, @@ -10560,7 +10353,7 @@ static const yytype_int16 yytable[] = 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, 529, 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, 251, 252, - 967, 254, 0, 256, 257, 258, 259, 0, 260, 261, + 902, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, 287, 288, @@ -10591,10 +10384,10 @@ static const yytype_int16 yytable[] = 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, - 528, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 528, 0, 554, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, - 128, 0, 0, 0, 0, 0, 0, 1010, 0, 0, + 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, 154, 155, @@ -10609,7 +10402,7 @@ static const yytype_int16 yytable[] = 222, 223, 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, 529, 0, 242, 0, 243, 0, 244, - 245, 246, 247, 0, 248, 249, 250, 251, 252, 253, + 245, 246, 247, 0, 248, 249, 250, 251, 252, 906, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, @@ -10641,10 +10434,10 @@ static const yytype_int16 yytable[] = 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 528, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 554, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, - 0, 0, 0, 0, 0, 0, 1037, 0, 0, 130, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, 154, 155, 156, @@ -10659,7 +10452,7 @@ static const yytype_int16 yytable[] = 223, 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, 529, 0, 242, 0, 243, 0, 244, 245, - 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, + 246, 247, 0, 248, 249, 250, 251, 252, 936, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, @@ -10691,9 +10484,9 @@ static const yytype_int16 yytable[] = 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 528, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 554, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, - 121, 122, 123, 124, 125, 827, 126, 127, 128, 0, + 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, @@ -10709,7 +10502,7 @@ static const yytype_int16 yytable[] = 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, 529, 0, 242, 0, 243, 0, 244, 245, 246, - 247, 0, 248, 249, 250, 251, 252, 253, 254, 0, + 247, 0, 248, 249, 250, 251, 252, 964, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, @@ -10733,7 +10526,7 @@ static const yytype_int16 yytable[] = 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 531, 448, 449, 0, 0, 450, 451, 0, 452, 0, 454, 455, 456, - 457, 458, 0, 459, 831, 461, 0, 0, 832, 463, + 457, 458, 0, 459, 460, 461, 0, 0, 462, 463, 464, 465, 466, 0, 467, 468, 469, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, 488, @@ -10759,7 +10552,7 @@ static const yytype_int16 yytable[] = 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, 529, 0, 242, 0, 243, 0, 244, 245, 246, 247, - 0, 248, 249, 250, 251, 252, 1326, 254, 0, 256, + 0, 248, 249, 250, 251, 252, 967, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, @@ -10790,11 +10583,11 @@ static const yytype_int16 yytable[] = 0, 490, 0, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, - 515, 516, 517, 518, 519, 520, 528, 0, 554, 0, + 515, 516, 517, 518, 519, 520, 528, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, + 0, 0, 0, 1010, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, 154, 155, 156, 0, 157, 158, @@ -10809,7 +10602,7 @@ static const yytype_int16 yytable[] = 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, 529, 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, - 248, 249, 250, 251, 252, 1328, 254, 0, 256, 257, + 248, 249, 250, 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, @@ -10840,11 +10633,11 @@ static const yytype_int16 yytable[] = 490, 0, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 520, 528, 0, 554, 0, 0, + 516, 517, 518, 519, 520, 528, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, + 0, 0, 1037, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, 154, 155, 156, 0, 157, 158, 159, @@ -10859,7 +10652,7 @@ static const yytype_int16 yytable[] = 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, 529, 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, - 249, 250, 251, 252, 1331, 254, 0, 256, 257, 258, + 249, 250, 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, @@ -10890,10 +10683,10 @@ static const yytype_int16 yytable[] = 0, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, - 517, 518, 519, 520, 528, 0, 554, 0, 0, 0, + 517, 518, 519, 520, 528, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, - 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, + 125, 827, 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, @@ -10909,7 +10702,7 @@ static const yytype_int16 yytable[] = 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, 529, 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, - 250, 251, 252, 1333, 254, 0, 256, 257, 258, 259, + 250, 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, @@ -10933,7 +10726,7 @@ static const yytype_int16 yytable[] = 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 531, 448, 449, 0, 0, 450, 451, 0, 452, 0, 454, 455, 456, 457, 458, 0, 459, - 460, 461, 0, 0, 462, 463, 464, 465, 466, 0, + 831, 461, 0, 0, 832, 463, 464, 465, 466, 0, 467, 468, 469, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, 488, 489, 0, 490, 0, @@ -10959,7 +10752,7 @@ static const yytype_int16 yytable[] = 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, 529, 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, - 251, 252, 2280, 254, 0, 256, 257, 258, 259, 0, + 251, 252, 1326, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, @@ -10990,305 +10783,57 @@ static const yytype_int16 yytable[] = 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, - 519, 520, 1502, 0, 0, 0, 0, 0, 0, 0, + 519, 520, 528, 0, 554, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, - 126, 127, 128, 0, 0, 0, 1503, 0, 0, -808, - 0, 1504, 130, 131, 0, 132, 133, 134, 1505, 136, - 137, 138, 0, 1506, 1507, 1508, 1509, 0, 144, 145, + 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, + 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, - 1510, 1511, 156, 0, 157, 158, 159, 160, 0, 0, - 1512, 0, 1513, 164, 165, 166, 167, 168, 1514, 170, + 154, 155, 156, 0, 157, 158, 159, 160, 161, 0, + 0, 0, 163, 164, 165, 166, 167, 168, 0, 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, - 1515, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 189, 1516, 191, 192, 1517, 194, 0, 195, 0, 196, + 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, - 205, 0, 0, 206, 207, 1073, 209, 210, 0, 211, + 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, - 220, 0, 222, 223, 224, 225, 226, 227, 0, 0, - 229, 0, 230, 231, 1518, 233, 0, 234, 0, 235, - 1519, 0, 1520, 238, 239, -808, 1521, 242, 0, 243, - 0, 0, 0, 246, 247, 0, 248, 249, 250, 251, - 252, 253, 254, 1522, 256, 257, 258, 259, 0, 260, - 261, 262, 263, 264, 265, 266, 0, 267, 1523, 0, - 270, 271, 272, 273, 274, 1524, 1525, 0, 1526, 0, - 278, 1527, 1528, 281, 1529, 283, 284, 285, 286, 287, - 288, 0, 0, 289, 1530, 291, 1531, 0, 293, 294, - 295, 296, 297, 298, 299, 300, 1532, 302, 303, 304, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 0, + 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, + 0, 0, 0, 238, 239, 529, 0, 242, 0, 243, + 0, 244, 245, 246, 247, 0, 248, 249, 250, 251, + 252, 1328, 254, 0, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, + 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, + 278, 0, 0, 281, 0, 283, 284, 285, 286, 287, + 288, 0, 0, 289, 0, 291, 0, 0, 293, 294, + 295, 296, 297, 298, 299, 300, 530, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 1533, 1534, 1535, - 325, 326, 327, 0, 0, 329, 330, 1536, 332, 0, - 0, 334, 1537, 336, 337, 338, 0, 339, 340, 0, - 0, 341, 342, 343, 0, 0, 344, 345, 0, 1538, - 348, 1539, 0, 351, 352, 353, 354, 355, 356, 357, + 315, 316, 317, 318, 319, 320, 321, 322, 0, 324, + 325, 326, 327, 328, 0, 329, 330, 0, 332, 0, + 333, 334, 335, 336, 337, 338, 0, 339, 340, 0, + 0, 341, 342, 343, 0, 0, 344, 345, 346, 0, + 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, - 0, 1540, 366, 367, 0, 369, 370, 371, 0, 372, + 364, 0, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, - 382, 1541, 384, 385, 386, 387, 0, 388, 389, 390, + 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, - 0, 401, 402, 1542, 404, 405, 406, 1543, 408, 409, + 0, 401, 402, 0, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, - 420, 0, 1544, 421, 422, 423, 424, 425, 426, 1545, - 428, 429, 0, 1546, 431, 432, 1547, 434, 0, 435, + 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, - 446, 1548, 448, 0, 0, 0, 450, 451, 0, 452, - 1549, 454, 455, 456, 457, 458, 0, 459, 1550, 1551, - 0, 0, 462, 463, 0, 465, 0, 0, 467, 468, - 1552, 470, 471, 472, 473, 474, 1553, 0, 475, 476, + 446, 531, 448, 449, 0, 0, 450, 451, 0, 452, + 0, 454, 455, 456, 457, 458, 0, 459, 460, 461, + 0, 0, 462, 463, 464, 465, 466, 0, 467, 468, + 469, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, - 485, 486, 0, 1554, 489, 0, 490, 1555, 492, 493, - 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, - 500, 501, 502, 503, 504, 505, 528, 0, 554, 0, - 0, 0, 0, 0, 0, 0, 0, 517, 518, 519, - 520, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, - 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, - 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, - 150, 151, 152, 153, 154, 155, 156, 0, 157, 158, - 159, 160, 161, 0, 0, 0, 163, 164, 165, 166, - 167, 168, 0, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 0, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 208, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, - 0, 234, 0, 235, 0, 0, 0, 238, 239, 529, - 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, - 248, 249, 250, 251, 252, 3050, 254, 0, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, - 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 0, 291, - 0, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 530, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 0, 324, 325, 326, 327, 328, 0, 329, - 330, 0, 332, 0, 333, 334, 335, 336, 337, 338, - 0, 339, 340, 0, 0, 341, 342, 343, 0, 0, - 344, 345, 346, 0, 348, 0, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 364, 0, 366, 367, 368, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 0, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 0, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 0, 0, 431, 432, - 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 531, 448, 449, 0, 0, - 450, 451, 0, 452, 0, 454, 455, 456, 457, 458, - 0, 459, 460, 461, 0, 0, 462, 463, 464, 465, - 466, 0, 467, 468, 469, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 487, 488, 489, 0, - 490, 0, 492, 493, 494, 495, 496, 497, 498, 0, - 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, - 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 520, 528, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, - 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, - 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, - 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, - 151, 152, 153, 154, 155, 156, 0, 157, 158, 159, - 160, 161, 0, 0, 0, 163, 164, 165, 166, 167, - 168, 0, 170, 171, 172, 0, 173, 174, 175, 176, - 177, 178, 0, 0, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 190, 191, 192, 193, 194, 0, - 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, - 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, - 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, - 234, 0, 235, 0, 0, 0, 238, 239, 529, 0, - 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, - 249, 250, 251, 252, 253, 254, 0, 256, 257, 258, - 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, - 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, - 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, - 285, 286, 287, 288, 0, 0, 289, 0, 291, 0, - 0, 293, 294, 295, 296, 297, 298, 299, 300, 530, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, - 322, 0, 324, 325, 326, 327, 328, 0, 329, 330, - 0, 332, 0, 333, 334, 335, 336, 337, 338, 0, - 339, 340, 0, 0, 341, 342, 343, 0, 0, 344, - 345, 346, 0, 348, 0, 350, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, - 0, 362, 363, 364, 0, 366, 367, 368, 369, 370, - 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, - 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, - 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, - 398, 399, 400, 0, 401, 402, 0, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, - 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, - 425, 426, 427, 428, 429, 0, 0, 431, 432, 433, - 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, - 443, 444, 445, 446, 531, 448, 449, 0, 0, 450, - 451, 0, 452, 0, 454, 455, 456, 457, 458, 0, - 459, 460, 461, 0, 0, 462, 463, 464, 465, 466, - 0, 467, 468, 469, 470, 471, 472, 473, 474, 0, - 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, - 482, 483, 484, 485, 486, 487, 488, 489, 0, 490, - 0, 492, 493, 494, 495, 496, 497, 498, 0, 0, - 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, - 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, - 517, 518, 519, 520, 528, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, - 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, - 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, - 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, - 152, 153, 154, 155, 156, 0, 157, 158, 159, 160, - 161, 0, 0, 0, 163, 164, 165, 166, 167, 168, - 0, 170, 171, 172, 0, 173, 174, 175, 176, 177, - 178, 0, 0, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, - 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, - 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, - 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, - 0, 235, 0, 0, 0, 238, 239, 529, 0, 843, - 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, - 250, 251, 252, 253, 254, 0, 256, 257, 258, 259, - 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, - 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, - 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, - 286, 287, 288, 0, 0, 289, 0, 291, 0, 0, - 293, 294, 844, 296, 297, 298, 299, 300, 530, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 0, 324, 325, 326, 327, 328, 0, 329, 330, 0, - 332, 0, 333, 334, 335, 336, 337, 338, 0, 339, - 340, 0, 0, 341, 342, 343, 0, 0, 344, 345, - 346, 0, 348, 0, 350, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, - 362, 363, 364, 0, 366, 367, 368, 369, 370, 371, - 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, - 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, - 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, - 399, 400, 0, 401, 402, 0, 404, 405, 406, 407, - 408, 409, 410, 411, 845, 413, 414, 415, 416, 417, - 418, 419, 420, 0, 0, 421, 422, 423, 424, 846, - 426, 427, 428, 429, 0, 0, 431, 432, 433, 434, - 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, - 444, 445, 446, 531, 448, 449, 0, 0, 450, 451, - 0, 452, 0, 454, 455, 456, 457, 458, 0, 459, - 847, 461, 0, 0, 462, 463, 464, 465, 466, 0, - 467, 468, 469, 470, 471, 472, 473, 474, 0, 0, - 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, - 483, 484, 485, 486, 487, 488, 848, 0, 490, 0, - 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, - 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, - 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, - 518, 519, 520, 528, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, - 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, - 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, - 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, - 153, 154, 155, 156, 0, 157, 158, 159, 160, 161, - 0, 0, 0, 163, 164, 165, 166, 167, 168, 0, - 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, - 0, 0, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, - 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, - 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, - 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, - 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, - 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, - 235, 0, 0, 0, 238, 239, 529, 0, 242, 0, - 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, - 251, 252, 960, 254, 0, 256, 257, 258, 259, 0, - 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, - 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, - 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, - 287, 288, 0, 0, 289, 0, 291, 0, 0, 293, - 294, 295, 296, 297, 298, 299, 300, 530, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 321, 322, 0, - 324, 325, 326, 327, 328, 0, 329, 330, 0, 332, - 0, 333, 334, 335, 336, 337, 338, 0, 339, 340, - 0, 0, 341, 342, 343, 0, 0, 344, 345, 346, - 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, - 363, 364, 0, 366, 367, 368, 369, 370, 371, 0, - 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, - 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, - 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, - 400, 0, 401, 402, 0, 404, 405, 406, 407, 408, - 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, - 419, 420, 0, 0, 421, 422, 423, 424, 425, 426, - 427, 428, 429, 0, 0, 431, 432, 433, 434, 0, - 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, - 445, 446, 531, 448, 449, 0, 0, 450, 451, 0, - 452, 0, 454, 455, 456, 457, 458, 0, 459, 460, - 461, 0, 0, 462, 463, 464, 465, 466, 0, 467, - 468, 469, 470, 471, 472, 473, 474, 0, 0, 475, - 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, - 484, 485, 486, 487, 488, 489, 0, 490, 0, 492, - 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, - 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, - 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, - 519, 520, 528, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, - 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, - 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, - 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, - 154, 155, 156, 0, 157, 158, 159, 160, 161, 0, - 0, 0, 163, 164, 165, 166, 167, 168, 0, 170, - 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, - 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, - 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, - 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, - 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 0, - 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, - 0, 0, 0, 238, 239, 529, 0, 242, 0, 243, - 0, 244, 245, 246, 247, 0, 248, 249, 250, 251, - 252, 253, 254, 0, 256, 257, 258, 259, 0, 260, - 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, - 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, - 278, 0, 0, 281, 0, 283, 284, 285, 286, 287, - 288, 0, 0, 289, 0, 291, 0, 0, 293, 294, - 295, 296, 297, 298, 299, 300, 530, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 0, 324, - 325, 326, 327, 328, 0, 329, 330, 0, 332, 0, - 333, 334, 335, 336, 337, 338, 0, 339, 340, 0, - 0, 341, 342, 343, 0, 0, 344, 345, 346, 0, - 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, - 364, 0, 366, 367, 368, 369, 370, 371, 0, 372, - 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, - 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, - 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, - 0, 401, 402, 0, 404, 405, 406, 407, 408, 409, - 410, 411, 845, 413, 414, 415, 416, 417, 418, 419, - 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, - 428, 429, 0, 0, 431, 432, 433, 434, 0, 435, - 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, - 446, 531, 448, 449, 0, 0, 450, 451, 0, 452, - 0, 454, 455, 456, 457, 458, 0, 459, 847, 461, - 0, 0, 462, 463, 464, 465, 466, 0, 467, 468, - 469, 470, 471, 472, 473, 474, 0, 0, 475, 476, - 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, - 485, 486, 487, 488, 489, 0, 490, 0, 492, 493, + 485, 486, 487, 488, 489, 0, 490, 0, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, - 520, 528, 0, 0, 0, 0, 0, 0, 0, 0, + 520, 528, 0, 554, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, @@ -11307,7 +10852,7 @@ static const yytype_int16 yytable[] = 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, 529, 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, 251, 252, - 1322, 254, 0, 256, 257, 258, 259, 0, 260, 261, + 1331, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, 287, 288, @@ -11338,7 +10883,7 @@ static const yytype_int16 yytable[] = 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, - 528, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 528, 0, 554, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -11356,7 +10901,7 @@ static const yytype_int16 yytable[] = 222, 223, 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, 529, 0, 242, 0, 243, 0, 244, - 245, 246, 247, 0, 248, 249, 250, 251, 252, 1343, + 245, 246, 247, 0, 248, 249, 250, 251, 252, 1333, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, @@ -11388,10 +10933,10 @@ static const yytype_int16 yytable[] = 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 528, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 554, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, - 0, 0, 0, 0, 0, 0, 1698, 0, 0, 130, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, 154, 155, 156, @@ -11406,7 +10951,7 @@ static const yytype_int16 yytable[] = 223, 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, 529, 0, 242, 0, 243, 0, 244, 245, - 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, + 246, 247, 0, 248, 249, 250, 251, 252, 2282, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, @@ -11426,7 +10971,7 @@ static const yytype_int16 yytable[] = 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, 0, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, - 421, 422, 423, 424, 425, 0, 427, 428, 429, 0, + 421, 422, 423, 424, 425, 426, 427, 428, 429, 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 531, 448, 449, 0, 0, 450, 451, 0, 452, 0, 454, 455, @@ -11437,50 +10982,298 @@ static const yytype_int16 yytable[] = 488, 489, 0, 490, 0, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - 513, 514, 515, 516, 517, 518, 519, 520, 528, 0, + 513, 514, 515, 516, 517, 518, 519, 520, 1502, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, - 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, - 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, - 0, 0, 150, 151, 152, 153, 154, 155, 156, 0, - 157, 158, 159, 160, 161, 0, 0, 0, 163, 164, - 165, 166, 167, 168, 0, 170, 171, 172, 0, 173, - 174, 175, 176, 177, 178, 0, 0, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, + 0, 0, 1503, 0, 0, -808, 0, 1504, 130, 131, + 0, 132, 133, 134, 1505, 136, 137, 138, 0, 1506, + 1507, 1508, 1509, 0, 144, 145, 146, 147, 148, 149, + 0, 0, 150, 151, 152, 153, 1510, 1511, 156, 0, + 157, 158, 159, 160, 0, 0, 1512, 0, 1513, 164, + 165, 166, 167, 168, 1514, 170, 171, 172, 0, 173, + 174, 175, 176, 177, 178, 0, 1515, 180, 181, 182, + 183, 184, 185, 186, 187, 188, 189, 1516, 191, 192, + 1517, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, - 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, - 215, 216, 0, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, - 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, - 239, 529, 0, 242, 0, 243, 0, 244, 245, 246, - 247, 0, 248, 249, 250, 251, 252, 1885, 254, 0, + 207, 1073, 209, 210, 0, 211, 212, 213, 0, 214, + 215, 216, 0, 217, 218, 219, 220, 0, 222, 223, + 224, 225, 226, 227, 0, 0, 229, 0, 230, 231, + 1518, 233, 0, 234, 0, 235, 1519, 0, 1520, 238, + 239, -808, 1521, 242, 0, 243, 0, 0, 0, 246, + 247, 0, 248, 249, 250, 251, 252, 253, 254, 1522, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, - 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, - 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, - 0, 283, 284, 285, 286, 287, 288, 0, 0, 289, - 0, 291, 0, 0, 293, 294, 295, 296, 297, 298, - 299, 300, 530, 302, 303, 304, 305, 306, 307, 308, + 265, 266, 0, 267, 1523, 0, 270, 271, 272, 273, + 274, 1524, 1525, 0, 1526, 0, 278, 1527, 1528, 281, + 1529, 283, 284, 285, 286, 287, 288, 0, 0, 289, + 1530, 291, 1531, 0, 293, 294, 295, 296, 297, 298, + 299, 300, 1532, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 322, 0, 324, 325, 326, 327, 328, - 0, 329, 330, 0, 332, 0, 333, 334, 335, 336, + 319, 320, 321, 1533, 1534, 1535, 325, 326, 327, 0, + 0, 329, 330, 1536, 332, 0, 0, 334, 1537, 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, 343, - 0, 0, 344, 345, 346, 0, 348, 0, 350, 351, + 0, 0, 344, 345, 0, 1538, 348, 1539, 0, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, - 0, 0, 0, 0, 362, 363, 364, 0, 366, 367, - 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, - 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, + 0, 0, 0, 0, 362, 363, 0, 1540, 366, 367, + 0, 369, 370, 371, 0, 372, 373, 374, 375, 376, + 377, 0, 378, 379, 380, 381, 382, 1541, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 397, 398, 399, 400, 0, 401, 402, 0, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, - 422, 423, 424, 425, 426, 427, 428, 429, 0, 0, - 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, - 440, 441, 442, 443, 444, 445, 446, 531, 448, 449, - 0, 0, 450, 451, 0, 452, 0, 454, 455, 456, - 457, 458, 0, 459, 460, 461, 0, 0, 462, 463, + 395, 396, 397, 398, 399, 400, 0, 401, 402, 1542, + 404, 405, 406, 1543, 408, 409, 410, 411, 412, 413, + 414, 415, 416, 417, 418, 419, 420, 0, 1544, 421, + 422, 423, 424, 425, 426, 1545, 428, 429, 0, 1546, + 431, 432, 1547, 434, 0, 435, 436, 437, 438, 439, + 440, 441, 442, 443, 444, 445, 446, 1548, 448, 0, + 0, 0, 450, 451, 0, 452, 1549, 454, 455, 456, + 457, 458, 0, 459, 1550, 1551, 0, 0, 462, 463, + 0, 465, 0, 0, 467, 468, 1552, 470, 471, 472, + 473, 474, 1553, 0, 475, 476, 477, 0, 478, 479, + 480, 481, 0, 482, 483, 484, 485, 486, 0, 1554, + 489, 0, 490, 1555, 492, 493, 494, 495, 496, 497, + 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, + 504, 505, 528, 0, 554, 0, 0, 0, 0, 0, + 0, 0, 0, 517, 518, 519, 520, 0, 0, 0, + 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, + 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, + 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, + 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, + 154, 155, 156, 0, 157, 158, 159, 160, 161, 0, + 0, 0, 163, 164, 165, 166, 167, 168, 0, 170, + 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, + 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, + 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, + 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, + 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 0, + 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, + 0, 0, 0, 238, 239, 529, 0, 242, 0, 243, + 0, 244, 245, 246, 247, 0, 248, 249, 250, 251, + 252, 3051, 254, 0, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, + 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, + 278, 0, 0, 281, 0, 283, 284, 285, 286, 287, + 288, 0, 0, 289, 0, 291, 0, 0, 293, 294, + 295, 296, 297, 298, 299, 300, 530, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 0, 324, + 325, 326, 327, 328, 0, 329, 330, 0, 332, 0, + 333, 334, 335, 336, 337, 338, 0, 339, 340, 0, + 0, 341, 342, 343, 0, 0, 344, 345, 346, 0, + 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, + 364, 0, 366, 367, 368, 369, 370, 371, 0, 372, + 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, + 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 0, 401, 402, 0, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 0, 0, 431, 432, 433, 434, 0, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, 531, 448, 449, 0, 0, 450, 451, 0, 452, + 0, 454, 455, 456, 457, 458, 0, 459, 460, 461, + 0, 0, 462, 463, 464, 465, 466, 0, 467, 468, + 469, 470, 471, 472, 473, 474, 0, 0, 475, 476, + 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, + 485, 486, 487, 488, 489, 0, 490, 0, 492, 493, + 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, + 520, 528, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, + 127, 128, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 130, 131, 0, 132, 133, 134, 0, 136, 137, + 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, + 147, 148, 149, 0, 0, 150, 151, 152, 153, 154, + 155, 156, 0, 157, 158, 159, 160, 161, 0, 0, + 0, 163, 164, 165, 166, 167, 168, 0, 170, 171, + 172, 0, 173, 174, 175, 176, 177, 178, 0, 0, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, + 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, + 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, + 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 0, 229, + 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, + 0, 0, 238, 239, 529, 0, 242, 0, 243, 0, + 244, 245, 246, 247, 0, 248, 249, 250, 251, 252, + 253, 254, 0, 256, 257, 258, 259, 0, 260, 261, + 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, + 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, + 0, 0, 281, 0, 283, 284, 285, 286, 287, 288, + 0, 0, 289, 0, 291, 0, 0, 293, 294, 295, + 296, 297, 298, 299, 300, 530, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 0, 324, 325, + 326, 327, 328, 0, 329, 330, 0, 332, 0, 333, + 334, 335, 336, 337, 338, 0, 339, 340, 0, 0, + 341, 342, 343, 0, 0, 344, 345, 346, 0, 348, + 0, 350, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 360, 361, 0, 0, 0, 0, 362, 363, 364, + 0, 366, 367, 368, 369, 370, 371, 0, 372, 373, + 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, + 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, + 401, 402, 0, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, + 0, 0, 421, 422, 423, 424, 425, 426, 427, 428, + 429, 0, 0, 431, 432, 433, 434, 0, 435, 436, + 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, + 531, 448, 449, 0, 0, 450, 451, 0, 452, 0, + 454, 455, 456, 457, 458, 0, 459, 460, 461, 0, + 0, 462, 463, 464, 465, 466, 0, 467, 468, 469, + 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, + 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, + 486, 487, 488, 489, 0, 490, 0, 492, 493, 494, + 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, + 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, + 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, + 528, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, + 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, + 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 130, 131, 0, 132, 133, 134, 0, 136, 137, 138, + 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, + 148, 149, 0, 0, 150, 151, 152, 153, 154, 155, + 156, 0, 157, 158, 159, 160, 161, 0, 0, 0, + 163, 164, 165, 166, 167, 168, 0, 170, 171, 172, + 0, 173, 174, 175, 176, 177, 178, 0, 0, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, + 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, + 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, + 0, 214, 215, 216, 0, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 0, 229, 0, + 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, + 0, 238, 239, 529, 0, 843, 0, 243, 0, 244, + 245, 246, 247, 0, 248, 249, 250, 251, 252, 253, + 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, + 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, + 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, + 0, 281, 0, 283, 284, 285, 286, 287, 288, 0, + 0, 289, 0, 291, 0, 0, 293, 294, 844, 296, + 297, 298, 299, 300, 530, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, + 317, 318, 319, 320, 321, 322, 0, 324, 325, 326, + 327, 328, 0, 329, 330, 0, 332, 0, 333, 334, + 335, 336, 337, 338, 0, 339, 340, 0, 0, 341, + 342, 343, 0, 0, 344, 345, 346, 0, 348, 0, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, 361, 0, 0, 0, 0, 362, 363, 364, 0, + 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, + 375, 376, 377, 0, 378, 379, 380, 381, 382, 383, + 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, + 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, + 402, 0, 404, 405, 406, 407, 408, 409, 410, 411, + 845, 413, 414, 415, 416, 417, 418, 419, 420, 0, + 0, 421, 422, 423, 424, 846, 426, 427, 428, 429, + 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, + 438, 439, 440, 441, 442, 443, 444, 445, 446, 531, + 448, 449, 0, 0, 450, 451, 0, 452, 0, 454, + 455, 456, 457, 458, 0, 459, 847, 461, 0, 0, + 462, 463, 464, 465, 466, 0, 467, 468, 469, 470, + 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, + 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, + 487, 488, 848, 0, 490, 0, 492, 493, 494, 495, + 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, + 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, + 512, 513, 514, 515, 516, 517, 518, 519, 520, 528, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, + 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 130, + 131, 0, 132, 133, 134, 0, 136, 137, 138, 139, + 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, + 149, 0, 0, 150, 151, 152, 153, 154, 155, 156, + 0, 157, 158, 159, 160, 161, 0, 0, 0, 163, + 164, 165, 166, 167, 168, 0, 170, 171, 172, 0, + 173, 174, 175, 176, 177, 178, 0, 0, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, + 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, + 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, + 214, 215, 216, 0, 217, 218, 219, 220, 221, 222, + 223, 224, 225, 226, 227, 228, 0, 229, 0, 230, + 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, + 238, 239, 529, 0, 242, 0, 243, 0, 244, 245, + 246, 247, 0, 248, 249, 250, 251, 252, 960, 254, + 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, + 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, + 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, + 281, 0, 283, 284, 285, 286, 287, 288, 0, 0, + 289, 0, 291, 0, 0, 293, 294, 295, 296, 297, + 298, 299, 300, 530, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 0, 324, 325, 326, 327, + 328, 0, 329, 330, 0, 332, 0, 333, 334, 335, + 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, + 343, 0, 0, 344, 345, 346, 0, 348, 0, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + 361, 0, 0, 0, 0, 362, 363, 364, 0, 366, + 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, + 376, 377, 0, 378, 379, 380, 381, 382, 383, 384, + 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, + 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, + 0, 404, 405, 406, 407, 408, 409, 410, 411, 412, + 413, 414, 415, 416, 417, 418, 419, 420, 0, 0, + 421, 422, 423, 424, 425, 426, 427, 428, 429, 0, + 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, + 439, 440, 441, 442, 443, 444, 445, 446, 531, 448, + 449, 0, 0, 450, 451, 0, 452, 0, 454, 455, + 456, 457, 458, 0, 459, 460, 461, 0, 0, 462, + 463, 464, 465, 466, 0, 467, 468, 469, 470, 471, + 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, + 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, + 488, 489, 0, 490, 0, 492, 493, 494, 495, 496, + 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, + 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, + 513, 514, 515, 516, 517, 518, 519, 520, 528, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, + 121, 122, 123, 124, 125, 0, 126, 127, 128, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 130, 131, + 0, 132, 133, 134, 0, 136, 137, 138, 139, 140, + 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, + 0, 0, 150, 151, 152, 153, 154, 155, 156, 0, + 157, 158, 159, 160, 161, 0, 0, 0, 163, 164, + 165, 166, 167, 168, 0, 170, 171, 172, 0, 173, + 174, 175, 176, 177, 178, 0, 0, 180, 181, 182, + 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, + 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, + 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, + 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, + 215, 216, 0, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 0, 229, 0, 230, 231, + 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, + 239, 529, 0, 242, 0, 243, 0, 244, 245, 246, + 247, 0, 248, 249, 250, 251, 252, 253, 254, 0, + 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, + 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, + 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, + 0, 283, 284, 285, 286, 287, 288, 0, 0, 289, + 0, 291, 0, 0, 293, 294, 295, 296, 297, 298, + 299, 300, 530, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 0, 324, 325, 326, 327, 328, + 0, 329, 330, 0, 332, 0, 333, 334, 335, 336, + 337, 338, 0, 339, 340, 0, 0, 341, 342, 343, + 0, 0, 344, 345, 346, 0, 348, 0, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, + 0, 0, 0, 0, 362, 363, 364, 0, 366, 367, + 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, + 377, 0, 378, 379, 380, 381, 382, 383, 384, 385, + 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, + 395, 396, 397, 398, 399, 400, 0, 401, 402, 0, + 404, 405, 406, 407, 408, 409, 410, 411, 845, 413, + 414, 415, 416, 417, 418, 419, 420, 0, 0, 421, + 422, 423, 424, 425, 426, 427, 428, 429, 0, 0, + 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, + 440, 441, 442, 443, 444, 445, 446, 531, 448, 449, + 0, 0, 450, 451, 0, 452, 0, 454, 455, 456, + 457, 458, 0, 459, 847, 461, 0, 0, 462, 463, 464, 465, 466, 0, 467, 468, 469, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, 487, 488, @@ -11506,7 +11299,7 @@ static const yytype_int16 yytable[] = 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, 529, 0, 242, 0, 243, 0, 244, 245, 246, 247, - 0, 248, 249, 250, 251, 252, 2267, 254, 0, 256, + 0, 248, 249, 250, 251, 252, 1322, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, @@ -11556,7 +11349,7 @@ static const yytype_int16 yytable[] = 226, 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, 529, 0, 242, 0, 243, 0, 244, 245, 246, 247, 0, - 248, 249, 250, 251, 252, 2282, 254, 0, 256, 257, + 248, 249, 250, 251, 252, 1343, 254, 0, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, 283, @@ -11587,26 +11380,274 @@ static const yytype_int16 yytable[] = 490, 0, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, - 516, 517, 518, 519, 520, 1502, 0, 0, 0, 0, + 516, 517, 518, 519, 520, 528, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, - 124, 125, 0, 126, 127, 128, 0, 0, 0, 1503, - 0, 0, 0, 0, 1504, 130, 131, 0, 132, 133, - 134, 1505, 136, 137, 138, 0, 1506, 1507, 1508, 1509, + 124, 125, 0, 126, 127, 128, 0, 0, 0, 0, + 0, 0, 1698, 0, 0, 130, 131, 0, 132, 133, + 134, 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, - 151, 152, 153, 1510, 1511, 156, 0, 157, 158, 159, - 160, 0, 0, 1512, 0, 1513, 164, 165, 166, 167, - 168, 1514, 170, 171, 172, 0, 173, 174, 175, 176, - 177, 178, 0, 1515, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 1516, 191, 192, 1517, 194, 0, + 151, 152, 153, 154, 155, 156, 0, 157, 158, 159, + 160, 161, 0, 0, 0, 163, 164, 165, 166, 167, + 168, 0, 170, 171, 172, 0, 173, 174, 175, 176, + 177, 178, 0, 0, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, - 202, 203, 204, 205, 0, 0, 206, 207, 1073, 209, + 202, 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, - 217, 218, 219, 220, 0, 222, 223, 224, 225, 226, - 227, 0, 0, 229, 0, 230, 231, 1518, 233, 0, - 234, 0, 235, 1519, 0, 1520, 238, 239, 0, 1521, - 242, 0, 243, 0, 0, 0, 246, 247, 0, 248, - 249, 250, 251, 252, 253, 254, 1522, 256, 257, 258, + 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 0, 229, 0, 230, 231, 232, 233, 0, + 234, 0, 235, 0, 0, 0, 238, 239, 529, 0, + 242, 0, 243, 0, 244, 245, 246, 247, 0, 248, + 249, 250, 251, 252, 253, 254, 0, 256, 257, 258, + 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, + 267, 0, 269, 270, 271, 272, 273, 274, 275, 276, + 0, 277, 0, 278, 0, 0, 281, 0, 283, 284, + 285, 286, 287, 288, 0, 0, 289, 0, 291, 0, + 0, 293, 294, 295, 296, 297, 298, 299, 300, 530, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 0, 324, 325, 326, 327, 328, 0, 329, 330, + 0, 332, 0, 333, 334, 335, 336, 337, 338, 0, + 339, 340, 0, 0, 341, 342, 343, 0, 0, 344, + 345, 346, 0, 348, 0, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, 361, 0, 0, 0, + 0, 362, 363, 364, 0, 366, 367, 368, 369, 370, + 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, + 379, 380, 381, 382, 383, 384, 385, 386, 387, 0, + 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, + 398, 399, 400, 0, 401, 402, 0, 404, 405, 406, + 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 417, 418, 419, 420, 0, 0, 421, 422, 423, 424, + 425, 0, 427, 428, 429, 0, 0, 431, 432, 433, + 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, + 443, 444, 445, 446, 531, 448, 449, 0, 0, 450, + 451, 0, 452, 0, 454, 455, 456, 457, 458, 0, + 459, 460, 461, 0, 0, 462, 463, 464, 465, 466, + 0, 467, 468, 469, 470, 471, 472, 473, 474, 0, + 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, + 482, 483, 484, 485, 486, 487, 488, 489, 0, 490, + 0, 492, 493, 494, 495, 496, 497, 498, 0, 0, + 499, 0, 0, 500, 501, 502, 503, 504, 505, 506, + 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, + 517, 518, 519, 520, 528, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, + 125, 0, 126, 127, 128, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 130, 131, 0, 132, 133, 134, + 0, 136, 137, 138, 139, 140, 0, 142, 143, 0, + 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, + 152, 153, 154, 155, 156, 0, 157, 158, 159, 160, + 161, 0, 0, 0, 163, 164, 165, 166, 167, 168, + 0, 170, 171, 172, 0, 173, 174, 175, 176, 177, + 178, 0, 0, 180, 181, 182, 183, 184, 185, 186, + 187, 188, 189, 190, 191, 192, 193, 194, 0, 195, + 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, + 203, 204, 205, 0, 0, 206, 207, 208, 209, 210, + 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 0, 229, 0, 230, 231, 232, 233, 0, 234, + 0, 235, 0, 0, 0, 238, 239, 529, 0, 242, + 0, 243, 0, 244, 245, 246, 247, 0, 248, 249, + 250, 251, 252, 1887, 254, 0, 256, 257, 258, 259, + 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, + 0, 269, 270, 271, 272, 273, 274, 275, 276, 0, + 277, 0, 278, 0, 0, 281, 0, 283, 284, 285, + 286, 287, 288, 0, 0, 289, 0, 291, 0, 0, + 293, 294, 295, 296, 297, 298, 299, 300, 530, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, + 0, 324, 325, 326, 327, 328, 0, 329, 330, 0, + 332, 0, 333, 334, 335, 336, 337, 338, 0, 339, + 340, 0, 0, 341, 342, 343, 0, 0, 344, 345, + 346, 0, 348, 0, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, 361, 0, 0, 0, 0, + 362, 363, 364, 0, 366, 367, 368, 369, 370, 371, + 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, + 380, 381, 382, 383, 384, 385, 386, 387, 0, 388, + 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, + 399, 400, 0, 401, 402, 0, 404, 405, 406, 407, + 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, + 418, 419, 420, 0, 0, 421, 422, 423, 424, 425, + 426, 427, 428, 429, 0, 0, 431, 432, 433, 434, + 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, + 444, 445, 446, 531, 448, 449, 0, 0, 450, 451, + 0, 452, 0, 454, 455, 456, 457, 458, 0, 459, + 460, 461, 0, 0, 462, 463, 464, 465, 466, 0, + 467, 468, 469, 470, 471, 472, 473, 474, 0, 0, + 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, + 483, 484, 485, 486, 487, 488, 489, 0, 490, 0, + 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, + 0, 0, 500, 501, 502, 503, 504, 505, 506, 507, + 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, + 518, 519, 520, 528, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, + 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, + 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, + 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, + 153, 154, 155, 156, 0, 157, 158, 159, 160, 161, + 0, 0, 0, 163, 164, 165, 166, 167, 168, 0, + 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, + 0, 0, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, + 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, + 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, + 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, + 235, 0, 0, 0, 238, 239, 529, 0, 242, 0, + 243, 0, 244, 245, 246, 247, 0, 248, 249, 250, + 251, 252, 2269, 254, 0, 256, 257, 258, 259, 0, + 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, + 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, + 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, + 287, 288, 0, 0, 289, 0, 291, 0, 0, 293, + 294, 295, 296, 297, 298, 299, 300, 530, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 322, 0, + 324, 325, 326, 327, 328, 0, 329, 330, 0, 332, + 0, 333, 334, 335, 336, 337, 338, 0, 339, 340, + 0, 0, 341, 342, 343, 0, 0, 344, 345, 346, + 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, + 363, 364, 0, 366, 367, 368, 369, 370, 371, 0, + 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, + 381, 382, 383, 384, 385, 386, 387, 0, 388, 389, + 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, + 400, 0, 401, 402, 0, 404, 405, 406, 407, 408, + 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, + 419, 420, 0, 0, 421, 422, 423, 424, 425, 426, + 427, 428, 429, 0, 0, 431, 432, 433, 434, 0, + 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, + 445, 446, 531, 448, 449, 0, 0, 450, 451, 0, + 452, 0, 454, 455, 456, 457, 458, 0, 459, 460, + 461, 0, 0, 462, 463, 464, 465, 466, 0, 467, + 468, 469, 470, 471, 472, 473, 474, 0, 0, 475, + 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, + 484, 485, 486, 487, 488, 489, 0, 490, 0, 492, + 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, + 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, + 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, + 519, 520, 528, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, + 126, 127, 128, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 130, 131, 0, 132, 133, 134, 0, 136, + 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, + 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, + 154, 155, 156, 0, 157, 158, 159, 160, 161, 0, + 0, 0, 163, 164, 165, 166, 167, 168, 0, 170, + 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, + 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, + 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, + 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, + 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 0, + 229, 0, 230, 231, 232, 233, 0, 234, 0, 235, + 0, 0, 0, 238, 239, 529, 0, 242, 0, 243, + 0, 244, 245, 246, 247, 0, 248, 249, 250, 251, + 252, 2284, 254, 0, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 0, 269, + 270, 271, 272, 273, 274, 275, 276, 0, 277, 0, + 278, 0, 0, 281, 0, 283, 284, 285, 286, 287, + 288, 0, 0, 289, 0, 291, 0, 0, 293, 294, + 295, 296, 297, 298, 299, 300, 530, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 0, 324, + 325, 326, 327, 328, 0, 329, 330, 0, 332, 0, + 333, 334, 335, 336, 337, 338, 0, 339, 340, 0, + 0, 341, 342, 343, 0, 0, 344, 345, 346, 0, + 348, 0, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, + 364, 0, 366, 367, 368, 369, 370, 371, 0, 372, + 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, + 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 0, 401, 402, 0, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 0, 0, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 0, 0, 431, 432, 433, 434, 0, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, 531, 448, 449, 0, 0, 450, 451, 0, 452, + 0, 454, 455, 456, 457, 458, 0, 459, 460, 461, + 0, 0, 462, 463, 464, 465, 466, 0, 467, 468, + 469, 470, 471, 472, 473, 474, 0, 0, 475, 476, + 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, + 485, 486, 487, 488, 489, 0, 490, 0, 492, 493, + 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, + 520, 1502, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, + 127, 128, 0, 0, 0, 1503, 0, 0, 0, 0, + 1504, 130, 131, 0, 132, 133, 134, 1505, 136, 137, + 138, 0, 1506, 1507, 1508, 1509, 0, 144, 145, 146, + 147, 148, 149, 0, 0, 150, 151, 152, 153, 1510, + 1511, 156, 0, 157, 158, 159, 160, 0, 0, 1512, + 0, 1513, 164, 165, 166, 167, 168, 1514, 170, 171, + 172, 0, 173, 174, 175, 176, 177, 178, 0, 1515, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 1516, 191, 192, 1517, 194, 0, 195, 0, 196, 197, + 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, + 0, 0, 206, 207, 1073, 209, 210, 0, 211, 212, + 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, + 0, 222, 223, 224, 225, 226, 227, 0, 0, 229, + 0, 230, 231, 1518, 233, 0, 234, 0, 235, 1519, + 0, 1520, 238, 239, 0, 1521, 242, 0, 243, 0, + 0, 0, 246, 247, 0, 248, 249, 250, 251, 252, + 253, 254, 1522, 256, 257, 258, 259, 0, 260, 261, + 262, 263, 264, 265, 266, 0, 267, 1523, 0, 270, + 271, 272, 273, 274, 1524, 1525, 0, 1526, 0, 278, + 1527, 1528, 281, 1529, 283, 284, 285, 286, 287, 288, + 0, 0, 289, 1530, 291, 1531, 0, 293, 294, 295, + 296, 297, 298, 299, 300, 1532, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 1533, 1534, 1535, 325, + 326, 327, 0, 0, 329, 330, 1536, 332, 0, 0, + 334, 1537, 336, 337, 338, 0, 339, 340, 0, 0, + 341, 342, 343, 0, 0, 344, 345, 0, 1538, 348, + 1539, 0, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 360, 361, 0, 0, 0, 0, 362, 363, 0, + 1540, 366, 367, 0, 369, 370, 371, 0, 372, 373, + 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, + 1541, 384, 385, 386, 387, 0, 388, 389, 390, 391, + 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, + 401, 402, 1542, 404, 405, 406, 1543, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, + 0, 1544, 421, 422, 423, 424, 425, 426, 1545, 428, + 429, 0, 1546, 431, 432, 1547, 434, 0, 435, 436, + 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, + 1548, 448, 0, 0, 0, 450, 451, 0, 452, 1549, + 454, 455, 456, 457, 458, 0, 459, 1550, 1551, 0, + 0, 462, 463, 0, 465, 0, 0, 467, 468, 1552, + 470, 471, 472, 473, 474, 1553, 0, 475, 476, 477, + 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, + 486, 0, 1554, 489, 0, 490, 1555, 492, 493, 494, + 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, + 501, 502, 503, 504, 505, 1502, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 517, 518, 519, 520, + 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, + 124, 125, 0, 126, 127, 128, 0, 0, 0, 1503, + 0, 0, 0, 0, 1504, 130, 131, 0, 132, 133, + 134, 1505, 136, 137, 138, 0, 1506, 1507, 1508, 1509, + 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, + 151, 152, 153, 1510, 1511, 156, 0, 157, 158, 159, + 160, 0, 0, 1512, 0, 1513, 164, 165, 166, 167, + 168, 1514, 170, 171, 172, 0, 173, 174, 175, 176, + 177, 178, 0, 1515, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 1516, 191, 192, 1517, 194, 0, + 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, + 202, 203, 204, 205, 0, 0, 206, 207, 1073, 209, + 210, 0, 211, 212, 213, 0, 1863, 215, 216, 0, + 217, 218, 219, 220, 0, 222, 223, 224, 225, 226, + 227, 0, 0, 229, 0, 230, 231, 1518, 233, 0, + 234, 0, 235, 1519, 0, 1520, 238, 239, 0, 1521, + 242, 0, 243, 0, 0, 0, 246, 247, 0, 248, + 249, 250, 251, 252, 253, 254, 1522, 256, 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, 0, 267, 1523, 0, 270, 271, 272, 273, 274, 1524, 1525, 0, 1526, 0, 278, 1527, 1528, 281, 1529, 283, 284, @@ -11635,3445 +11676,2718 @@ static const yytype_int16 yytable[] = 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, 0, 1554, 489, 0, 490, 1555, 492, 493, 494, 495, 496, 497, 498, 0, 0, - 499, 0, 0, 500, 501, 502, 503, 504, 505, 1502, + 499, 0, 0, 500, 501, 502, 503, 504, 505, 3233, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 517, 518, 519, 520, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, 0, 126, 127, 128, - 0, 0, 0, 1503, 0, 0, 0, 0, 1504, 130, - 131, 0, 132, 133, 134, 1505, 136, 137, 138, 0, - 1506, 1507, 1508, 1509, 0, 144, 145, 146, 147, 148, + 0, 0, 0, 2974, 0, 0, 0, 0, 2975, 130, + 131, 0, 132, 133, 134, 2976, 136, 137, 138, 0, + 1506, 2977, 1508, 1509, 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, 1510, 1511, 156, - 0, 157, 158, 159, 160, 0, 0, 1512, 0, 1513, - 164, 165, 166, 167, 168, 1514, 170, 171, 172, 0, - 173, 174, 175, 176, 177, 178, 0, 1515, 180, 181, + 0, 157, 158, 159, 160, 0, 0, 2978, 0, 2979, + 164, 165, 166, 167, 168, 2980, 170, 171, 172, 0, + 173, 174, 175, 176, 177, 178, 0, 2981, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 1516, 191, 192, 1517, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, 1073, 209, 210, 0, 211, 212, 213, 0, - 1861, 215, 216, 0, 217, 218, 219, 220, 0, 222, + 214, 215, 216, 0, 217, 218, 219, 220, 0, 222, 223, 224, 225, 226, 227, 0, 0, 229, 0, 230, - 231, 1518, 233, 0, 234, 0, 235, 1519, 0, 1520, - 238, 239, 0, 1521, 242, 0, 243, 0, 0, 0, + 231, 1518, 233, 0, 234, 0, 235, 2982, 0, 2983, + 238, 239, 2984, 2985, 242, 0, 243, 0, 0, 0, 246, 247, 0, 248, 249, 250, 251, 252, 253, 254, - 1522, 256, 257, 258, 259, 0, 260, 261, 262, 263, - 264, 265, 266, 0, 267, 1523, 0, 270, 271, 272, - 273, 274, 1524, 1525, 0, 1526, 0, 278, 1527, 1528, - 281, 1529, 283, 284, 285, 286, 287, 288, 0, 0, - 289, 1530, 291, 1531, 0, 293, 294, 295, 296, 297, - 298, 299, 300, 1532, 302, 303, 304, 305, 306, 307, + 2986, 256, 257, 258, 259, 0, 260, 261, 262, 263, + 264, 265, 266, 0, 267, 2987, 0, 270, 271, 272, + 273, 274, 1524, 1525, 0, 1526, 0, 278, 2988, 2989, + 281, 2990, 283, 284, 285, 286, 287, 288, 0, 0, + 289, 2991, 291, 2992, 0, 293, 294, 295, 296, 297, + 298, 299, 300, 3234, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, 321, 1533, 1534, 1535, 325, 326, 327, - 0, 0, 329, 330, 1536, 332, 0, 0, 334, 1537, + 318, 319, 320, 321, 1533, 2994, 1535, 325, 326, 327, + 0, 0, 329, 330, 2996, 332, 0, 0, 334, 1537, 336, 337, 338, 0, 339, 340, 0, 0, 341, 342, - 343, 0, 0, 344, 345, 0, 1538, 348, 1539, 0, + 343, 0, 0, 344, 345, 0, 2998, 348, 2999, 0, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - 361, 0, 0, 0, 0, 362, 363, 0, 1540, 366, + 361, 0, 0, 0, 0, 362, 363, 0, 3000, 366, 367, 0, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, 382, 1541, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 0, 401, 402, - 1542, 404, 405, 406, 1543, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 417, 418, 419, 420, 0, 1544, - 421, 422, 423, 424, 425, 426, 1545, 428, 429, 0, - 1546, 431, 432, 1547, 434, 0, 435, 436, 437, 438, - 439, 440, 441, 442, 443, 444, 445, 446, 1548, 448, - 0, 0, 0, 450, 451, 0, 452, 1549, 454, 455, + 3001, 404, 405, 406, 0, 408, 409, 410, 411, 412, + 413, 414, 415, 416, 417, 418, 419, 420, 0, 3002, + 421, 422, 423, 424, 425, 426, 0, 428, 429, 0, + 3004, 431, 432, 1547, 434, 0, 435, 436, 437, 438, + 439, 440, 441, 442, 443, 444, 445, 446, 3235, 448, + 0, 0, 0, 450, 451, 0, 452, 3006, 454, 455, 456, 457, 458, 0, 459, 1550, 1551, 0, 0, 462, - 463, 0, 465, 0, 0, 467, 468, 1552, 470, 471, - 472, 473, 474, 1553, 0, 475, 476, 477, 0, 478, + 463, 0, 465, 0, 0, 467, 468, 3007, 470, 471, + 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, 485, 486, 0, - 1554, 489, 0, 490, 1555, 492, 493, 494, 495, 496, + 1554, 489, 0, 490, 3009, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, 0, 500, 501, 502, - 503, 504, 505, 3232, 0, 0, 0, 0, 0, 0, + 503, 504, 505, 528, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 517, 518, 519, 520, 0, 0, 0, 0, 118, 119, 120, 121, 122, 123, 124, 125, - 0, 126, 127, 128, 0, 0, 0, 2973, 0, 0, - 0, 0, 2974, 130, 131, 0, 132, 133, 134, 2975, - 136, 137, 138, 0, 1506, 2976, 1508, 1509, 0, 144, + 0, 126, 127, 128, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 130, 131, 0, 132, 133, 134, 0, + 136, 137, 138, 139, 140, 0, 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, 0, 150, 151, 152, - 153, 1510, 1511, 156, 0, 157, 158, 159, 160, 0, - 0, 2977, 0, 2978, 164, 165, 166, 167, 168, 2979, + 153, 154, 155, 156, 0, 157, 158, 159, 160, 161, + 0, 0, 0, 163, 164, 165, 166, 167, 168, 0, 170, 171, 172, 0, 173, 174, 175, 176, 177, 178, - 0, 2980, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 1516, 191, 192, 1517, 194, 0, 195, 0, + 0, 0, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, 0, 202, 203, - 204, 205, 0, 0, 206, 207, 1073, 209, 210, 0, + 204, 205, 0, 0, 206, 207, 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, - 219, 220, 0, 222, 223, 224, 225, 226, 227, 0, - 0, 229, 0, 230, 231, 1518, 233, 0, 234, 0, - 235, 2981, 0, 2982, 238, 239, 2983, 2984, 242, 0, - 243, 0, 0, 0, 246, 247, 0, 248, 249, 250, - 251, 252, 253, 254, 2985, 256, 257, 258, 259, 0, - 260, 261, 262, 263, 264, 265, 266, 0, 267, 2986, - 0, 270, 271, 272, 273, 274, 1524, 1525, 0, 1526, - 0, 278, 2987, 2988, 281, 2989, 283, 284, 285, 286, - 287, 288, 0, 0, 289, 2990, 291, 2991, 0, 293, - 294, 295, 296, 297, 298, 299, 300, 3233, 302, 303, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 0, 229, 0, 230, 231, 232, 233, 0, 234, 0, + 235, 0, 0, 0, 238, 239, 529, 0, 242, 0, + 243, 0, 244, 245, 0, 247, 0, 248, 249, 250, + 251, 252, 253, 254, 0, 256, 257, 258, 259, 0, + 260, 261, 262, 263, 264, 265, 266, 0, 267, 0, + 269, 270, 271, 272, 273, 274, 275, 276, 0, 277, + 0, 278, 0, 0, 281, 0, 283, 284, 285, 286, + 287, 288, 0, 0, 289, 0, 291, 0, 0, 293, + 294, 295, 296, 297, 298, 299, 300, 530, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 321, 1533, 2993, - 1535, 325, 326, 327, 0, 0, 329, 330, 2995, 332, - 0, 0, 334, 1537, 336, 337, 338, 0, 339, 340, - 0, 0, 341, 342, 343, 0, 0, 344, 345, 0, - 2997, 348, 2998, 0, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, 361, 0, 0, 0, 0, 362, - 363, 0, 2999, 366, 367, 0, 369, 370, 371, 0, + 314, 315, 316, 317, 318, 319, 320, 321, 322, 0, + 324, 325, 326, 327, 328, 0, 329, 330, 0, 332, + 0, 333, 334, 335, 336, 337, 338, 0, 339, 340, + 0, 0, 341, 342, 343, 0, 0, 344, 345, 346, + 0, 348, 0, 350, 351, 352, 353, 354, 355, 356, + 0, 358, 359, 360, 361, 0, 0, 0, 0, 362, + 363, 364, 0, 366, 367, 368, 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, 378, 379, 380, - 381, 382, 1541, 384, 385, 386, 387, 0, 388, 389, + 0, 382, 383, 384, 385, 386, 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, - 400, 0, 401, 402, 3000, 404, 405, 406, 0, 408, + 400, 0, 401, 402, 0, 404, 405, 406, 407, 0, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, - 419, 420, 0, 3001, 421, 422, 423, 424, 425, 426, - 0, 428, 429, 0, 3003, 431, 432, 1547, 434, 0, + 419, 420, 0, 0, 421, 422, 423, 424, 425, 426, + 427, 428, 429, 0, 0, 431, 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, - 445, 446, 3234, 448, 0, 0, 0, 450, 451, 0, - 452, 3005, 454, 455, 456, 457, 458, 0, 459, 1550, - 1551, 0, 0, 462, 463, 0, 465, 0, 0, 467, - 468, 3006, 470, 471, 472, 473, 474, 0, 0, 475, + 445, 446, 531, 448, 449, 0, 0, 450, 451, 0, + 452, 0, 454, 455, 456, 457, 458, 0, 459, 460, + 461, 0, 0, 462, 463, 464, 465, 466, 0, 467, + 468, 469, 470, 471, 472, 473, 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, 0, 482, 483, - 484, 485, 486, 0, 1554, 489, 0, 490, 3008, 492, + 484, 485, 486, 487, 488, 489, 0, 490, 0, 492, 493, 494, 495, 496, 497, 498, 0, 0, 499, 0, - 0, 500, 501, 502, 503, 504, 505, 528, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 517, 518, - 519, 520, 0, 0, 0, 0, 118, 119, 120, 121, - 122, 123, 124, 125, 0, 126, 127, 128, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 130, 131, 0, - 132, 133, 134, 0, 136, 137, 138, 139, 140, 0, - 142, 143, 0, 144, 145, 146, 147, 148, 149, 0, - 0, 150, 151, 152, 153, 154, 155, 156, 0, 157, - 158, 159, 160, 161, 0, 0, 0, 163, 164, 165, - 166, 167, 168, 0, 170, 171, 172, 0, 173, 174, - 175, 176, 177, 178, 0, 0, 180, 181, 182, 183, - 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - 194, 0, 195, 0, 196, 197, 198, 199, 200, 201, - 0, 0, 202, 203, 204, 205, 0, 0, 206, 207, - 208, 209, 210, 0, 211, 212, 213, 0, 214, 215, - 216, 0, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 0, 229, 0, 230, 231, 232, - 233, 0, 234, 0, 235, 0, 0, 0, 238, 239, - 529, 0, 242, 0, 243, 0, 244, 245, 0, 247, - 0, 248, 249, 250, 251, 252, 253, 254, 0, 256, - 257, 258, 259, 0, 260, 261, 262, 263, 264, 265, - 266, 0, 267, 0, 269, 270, 271, 272, 273, 274, - 275, 276, 0, 277, 0, 278, 0, 0, 281, 0, - 283, 284, 285, 286, 287, 288, 0, 0, 289, 0, - 291, 0, 0, 293, 294, 295, 296, 297, 298, 299, - 300, 530, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 0, 324, 325, 326, 327, 328, 0, - 329, 330, 0, 332, 0, 333, 334, 335, 336, 337, - 338, 0, 339, 340, 0, 0, 341, 342, 343, 0, - 0, 344, 345, 346, 0, 348, 0, 350, 351, 352, - 353, 354, 355, 356, 0, 358, 359, 360, 361, 0, - 0, 0, 0, 362, 363, 364, 0, 366, 367, 368, - 369, 370, 371, 0, 372, 373, 374, 375, 376, 377, - 0, 378, 379, 380, 0, 382, 383, 384, 385, 386, - 387, 0, 388, 389, 390, 391, 392, 393, 394, 395, - 396, 397, 398, 399, 400, 0, 401, 402, 0, 404, - 405, 406, 407, 0, 409, 410, 411, 412, 413, 414, - 415, 416, 417, 418, 419, 420, 0, 0, 421, 422, - 423, 424, 425, 426, 427, 428, 429, 0, 0, 431, - 432, 433, 434, 0, 435, 436, 437, 438, 439, 440, - 441, 442, 443, 444, 445, 446, 531, 448, 449, 0, - 0, 450, 451, 0, 452, 0, 454, 455, 456, 457, - 458, 0, 459, 460, 461, 0, 0, 462, 463, 464, - 465, 466, 0, 467, 468, 469, 470, 471, 472, 473, - 474, 0, 0, 475, 476, 477, 0, 478, 479, 480, - 481, 0, 482, 483, 484, 485, 486, 487, 488, 489, - 0, 490, 0, 492, 493, 494, 495, 496, 497, 498, - 0, 0, 499, 0, 0, 500, 501, 502, 503, 504, - 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, - 515, 516, 517, 518, 519, 520, 1797, 0, 0, 0, + 0, 500, 501, 502, 503, 504, 505, 506, 507, 508, + 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, + 519, 520, 1797, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 118, 119, 120, 121, 122, - 123, 124, 125, 0, 126, 127, 128, 0, 0, 0, - 1503, 0, 0, 0, 0, 1504, 130, 131, 0, 132, - 133, 134, 1505, 136, 137, 138, 0, 1506, 1507, 1508, - 1509, 0, 144, 145, 146, 147, 148, 149, 0, 0, - 150, 151, 152, 153, 1510, 1511, 156, 0, 157, 158, - 159, 160, 0, 0, 1512, 0, 1513, 164, 165, 166, - 167, 168, 1514, 170, 171, 172, 0, 173, 174, 175, - 176, 177, 178, 0, 1515, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 1516, 191, 192, 1517, 194, - 0, 195, 0, 196, 197, 198, 199, 200, 201, 0, - 0, 202, 203, 204, 205, 0, 0, 206, 207, 1073, - 209, 210, 0, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 0, 222, 223, 224, 225, - 226, 227, 0, 0, 229, 0, 230, 231, 1518, 233, - 0, 234, 0, 235, 1519, 0, 1520, 238, 239, 0, - 1521, 242, 0, 243, 0, 0, 0, 246, 247, 0, - 248, 249, 250, 251, 252, 253, 254, 1522, 256, 257, - 258, 259, 0, 260, 261, 262, 263, 264, 265, 266, - 0, 267, 1523, 0, 270, 271, 272, 273, 274, 1524, - 1525, 0, 1526, 0, 278, 1527, 1528, 281, 1529, 283, - 284, 285, 286, 287, 288, 0, 0, 289, 1530, 291, - 1531, 0, 293, 294, 295, 296, 297, 298, 299, 300, - 0, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 1533, 1534, 1535, 325, 326, 327, 0, 0, 329, - 330, 1536, 332, 0, 0, 334, 1537, 336, 337, 338, - 0, 339, 340, 0, 0, 341, 342, 343, 0, 0, - 344, 345, 0, 1538, 348, 1539, 0, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, 361, 0, 0, - 0, 0, 362, 363, 0, 1540, 366, 367, 0, 369, - 370, 371, 0, 372, 373, 374, 375, 376, 377, 0, - 378, 379, 380, 381, 382, 1541, 384, 385, 386, 387, - 0, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 0, 401, 402, 1542, 404, 405, - 406, 0, 408, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 0, 1544, 421, 422, 423, - 424, 425, 426, 0, 428, 429, 0, 1546, 431, 432, - 1547, 434, 0, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 0, 448, 0, 0, 0, - 450, 451, 0, 452, 1549, 454, 455, 456, 457, 458, - 0, 459, 1550, 1551, 0, 0, 462, 463, 0, 465, - 0, 0, 467, 468, 1552, 470, 471, 472, 473, 474, - 0, 0, 475, 476, 477, 0, 478, 479, 480, 481, - 0, 482, 483, 484, 485, 486, 0, 1554, 489, 0, - 490, 1555, 492, 493, 494, 495, 496, 497, 498, 0, - 1, 499, 0, 0, 500, 501, 502, 503, 504, 505, - 2, 0, 3, 4, 0, 0, 0, 0, 1, 0, - 0, 517, 518, 519, 520, 0, 0, 0, 2, 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, 751, 0, - 0, 0, 10, 0, 0, 0, 0, 0, 0, 13, - 0, 0, 0, 0, 11, 0, 751, 0, 0, 0, - 0, 0, 0, 0, 14, 15, 0, 13, 0, 0, - 0, 0, 0, 0, 0, 752, 0, 0, 0, 0, - 0, 18, 14, 15, 0, 0, 0, 0, 0, 19, - 0, 0, 0, 752, 0, 0, 0, 0, 0, 18, - 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, 118, 119, 120, 121, 122, 123, 124, 125, 0, + 126, 127, 128, 0, 0, 0, 1503, 0, 0, 0, + 0, 1504, 130, 131, 0, 132, 133, 134, 1505, 136, + 137, 138, 0, 1506, 1507, 1508, 1509, 0, 144, 145, + 146, 147, 148, 149, 0, 0, 150, 151, 152, 153, + 1510, 1511, 156, 0, 157, 158, 159, 160, 0, 0, + 1512, 0, 1513, 164, 165, 166, 167, 168, 1514, 170, + 171, 172, 0, 173, 174, 175, 176, 177, 178, 0, + 1515, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 1516, 191, 192, 1517, 194, 0, 195, 0, 196, + 197, 198, 199, 200, 201, 0, 0, 202, 203, 204, + 205, 0, 0, 206, 207, 1073, 209, 210, 0, 211, + 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, + 220, 0, 222, 223, 224, 225, 226, 227, 0, 0, + 229, 0, 230, 231, 1518, 233, 0, 234, 0, 235, + 1519, 0, 1520, 238, 239, 0, 1521, 242, 0, 243, + 0, 0, 0, 246, 247, 0, 248, 249, 250, 251, + 252, 253, 254, 1522, 256, 257, 258, 259, 0, 260, + 261, 262, 263, 264, 265, 266, 0, 267, 1523, 0, + 270, 271, 272, 273, 274, 1524, 1525, 0, 1526, 0, + 278, 1527, 1528, 281, 1529, 283, 284, 285, 286, 287, + 288, 0, 0, 289, 1530, 291, 1531, 0, 293, 294, + 295, 296, 297, 298, 299, 300, 0, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 1533, 1534, 1535, + 325, 326, 327, 0, 0, 329, 330, 1536, 332, 0, + 0, 334, 1537, 336, 337, 338, 0, 339, 340, 0, + 0, 341, 342, 343, 0, 0, 344, 345, 0, 1538, + 348, 1539, 0, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 0, 0, 0, 0, 362, 363, + 0, 1540, 366, 367, 0, 369, 370, 371, 0, 372, + 373, 374, 375, 376, 377, 0, 378, 379, 380, 381, + 382, 1541, 384, 385, 386, 387, 0, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, + 0, 401, 402, 1542, 404, 405, 406, 0, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 0, 1544, 421, 422, 423, 424, 425, 426, 0, + 428, 429, 0, 1546, 431, 432, 1547, 434, 0, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, 0, 448, 0, 0, 0, 450, 451, 0, 452, + 1549, 454, 455, 456, 457, 458, 0, 459, 1550, 1551, + 0, 0, 462, 463, 0, 465, 0, 0, 467, 468, + 1552, 470, 471, 472, 473, 474, 0, 0, 475, 476, + 477, 0, 478, 479, 480, 481, 0, 482, 483, 484, + 485, 486, 0, 1554, 489, 0, 490, 1555, 492, 493, + 494, 495, 496, 497, 498, 0, 1, 499, 0, 0, + 500, 501, 502, 503, 504, 505, 2, 0, 3, 4, + 0, 0, 0, 0, 1, 0, 0, 517, 518, 519, + 520, 0, 0, 0, 2, 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, 751, 0, 0, 0, 10, 0, + 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, + 11, 0, 751, 0, 0, 0, 0, 0, 0, 0, + 14, 15, 0, 13, 0, 0, 0, 0, 0, 0, + 0, 752, 0, 0, 0, 0, 0, 18, 14, 15, + 0, 0, 0, 0, 0, 19, 0, 0, 0, 752, + 0, 0, 0, 0, 0, 18, 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, 0, - 0, 0, -1468, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, -1468, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - -1468, 0, 0, 0, 0, 0, 0, 0, 25, 0, + 0, 0, 0, 0, 0, 0, -1468, 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, 25, 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, 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, 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, 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, 36, 0, 0, 0, 34, 0, 0, 0, 35, - 0, 0, 0, 37, 0, 0, 0, 38, 0, 36, + 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, 36, 0, 0, + 0, 34, 0, 0, 0, 35, 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, 39, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 40, 0, 0, 0, + 0, 39, 42, 0, 0, 0, 0, 43, 0, 0, + 0, 0, 753, 0, 40, 0, 0, 0, 0, 0, + 42, 0, 0, 0, 44, 43, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 37, 0, 0, 0, 38, 0, 39, 0, 0, + 0, 0, 44, 0, 0, 0, 0, 0, 45, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 40, 0, 0, 0, 0, 39, 42, 0, 0, 0, - 0, 43, 0, 0, 0, 0, 753, 0, 40, 0, - 0, 0, 0, 0, 42, 0, 0, 0, 44, 43, + 0, 0, 754, 0, 0, 0, 45, 0, 0, 0, 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, 754, 0, 0, 0, - 45, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 46 + 46 }; static const yytype_int16 yycheck[] = { - 7, 521, 0, 0, 0, 0, 841, 0, 903, 16, - 0, 0, 73, 930, 888, 815, 23, 0, 999, 746, - 1459, 914, 0, 0, 16, 38, 46, 0, 865, 1244, - 1175, 1256, 7, 1443, 754, 1242, 1045, 20, 980, 1230, - 20, 1683, 20, 965, 1720, 1217, 935, 1495, 23, 990, - 1093, 1612, 77, 1600, 990, 7, 1574, 1321, 990, 77, - 1828, 2219, 1219, 990, 37, 1655, 2209, 1210, 75, 76, - 1298, 23, 2188, 969, 2190, 1222, 980, 13, 2278, 1636, - 1637, 2027, 2365, 19, 0, 0, 2677, 1346, 0, 0, - 1247, 23, 17, 0, 30, 903, 2677, 905, 111, 907, - 75, 76, 0, 2208, 0, 1140, 45, 0, 44, 45, - 1145, 2714, 0, 2154, 2732, 1008, 0, 2326, 2327, 2328, - 1101, 753, 0, 75, 76, 34, 0, 810, 101, 2739, - 754, 2716, 2274, 816, 2544, 2345, 2631, 0, 747, 0, - 2635, 0, 0, 75, 76, 2028, 0, 1687, 0, 0, - 0, 988, 0, 0, 1067, 1068, 5, 1655, 1848, 0, - 1851, 3, 4, 5, 13, 14, 5, 9, 0, 1740, - 1738, 1084, 0, 109, 1965, 1847, 9, 4, 0, 5, - 40, 5, 9, 10, 55, 2846, 63, 13, 14, 13, - 14, 991, 3061, 75, 76, 5, 5, 5, 13, 14, - 778, 5, 2353, 13, 14, 13, 14, 5, 5, 1151, - 3047, 9, 5, 5, 5, 172, 9, 2351, 5, 5, - 5, 2357, 2357, 4, 2366, 80, 26, 3064, 9, 5, - 74, 45, 5, 23, 74, 5, 5, 3, 173, 5, - 45, 13, 14, 124, 119, 5, 122, 30, 11, 11, - 30, 172, 860, 16, 16, 38, 1265, 63, 38, 139, - 980, 883, 997, 1100, 1157, 1274, 11, 1184, 100, 172, - 15, 16, 100, 191, 63, 117, 9, 117, 2420, 2421, - 181, 2423, 30, 4, 46, 75, 76, 807, 9, 1231, - 38, 245, 1234, 1235, 107, 2901, 296, 3237, 1993, 1994, - 1995, 172, 2490, 290, 5, 291, 11, 883, 90, 992, - 15, 16, 288, 1458, 245, 0, 172, 3017, 80, 8, - 184, 1004, 11, 805, 193, 169, 15, 16, 2001, 2002, - 19, 20, 21, 63, 854, 20, 3, 137, 23, 2012, - 104, 46, 368, 2016, 2882, 291, 2884, 129, 3369, 107, - 1495, 983, 37, 82, 1545, 82, 2472, 132, 193, 245, - 2593, 46, 2595, 276, 93, 117, 93, 34, 35, 296, - 1205, 1206, 1209, 119, 2647, 80, 1640, 219, 53, 279, - 313, 40, 3432, 41, 64, 2594, 122, 107, 166, 120, - 75, 76, 77, 30, 74, 120, 3475, 11, 382, 241, - 11, 137, 83, 391, 1071, 148, 108, 149, 40, 2177, - 164, 3002, 315, 316, 317, 1332, 101, 181, 290, 373, - 1087, 1935, 3399, 122, 117, 433, 3263, 13, 14, 1303, - 122, 250, 46, 794, 507, 275, 369, 516, 108, 518, - 280, 3462, 373, 11, 3465, 518, 2646, 15, 16, 11, - 418, 812, 1966, 15, 16, 3058, 275, 200, 290, 201, - 132, 2619, 290, 30, 195, 30, 80, 148, 126, 80, - 195, 3056, 1361, 3523, 431, 483, 340, 231, 46, 382, - 2753, 3560, 3067, 360, 147, 329, 355, 373, 456, 329, - 192, 2532, 518, 162, 294, 132, 396, 451, 191, 3368, - 275, 2643, 177, 2645, 171, 369, 173, 347, 1551, 273, - 285, 75, 80, 1777, 213, 273, 419, 176, 85, 194, - 451, 213, 522, 358, 199, 2947, 308, 94, 280, 361, - 518, 518, 518, 361, 280, 3235, 1018, 3558, 522, 485, - 2101, 454, 518, 273, 176, 108, 324, 3524, 469, 452, - 507, 118, 3090, 2786, 360, 218, 457, 357, 3498, 359, - 463, 241, 237, 520, 518, 451, 539, 132, 518, 238, - 2160, 360, 2020, 1181, 3180, 431, 457, 2728, 454, 280, - 513, 167, 275, 518, 459, 1207, 593, 518, 1108, 389, - 1168, 2725, 328, 0, 3463, 522, 476, 1510, 1511, 1771, - 518, 593, 416, 292, 448, 1833, 419, 2154, 448, 2745, - 2745, 416, 1449, 285, 2802, 518, 399, 457, 1345, 399, - 556, 2763, 1535, 1350, 191, 3564, 2572, 3464, 1463, 1356, - 360, 1207, 518, 296, 3252, 2192, 1895, 204, 245, 2430, - 406, 407, 424, 1363, 214, 522, 3237, 518, 480, 1484, - 3311, 399, 480, 373, 1869, 2226, 3237, 2225, 419, 389, - 520, 516, 2160, 1927, 428, 520, 3605, 509, 510, 518, - 467, 2218, 2212, 2363, 521, 1939, 1685, 2368, 527, 518, - 521, 522, 1595, 1596, 517, 1910, 2358, 519, 527, 521, - 3185, 519, 518, 521, 518, 3190, 518, 524, 525, 521, - 1435, 1436, 431, 518, 431, 1969, 1441, 516, 518, 518, - 518, 520, 1976, 482, 518, 2925, 522, 513, 2918, 394, - 518, 518, 482, 3133, 520, 518, 518, 518, 509, 510, - 1362, 518, 518, 518, 754, 504, 1629, 1630, 1631, 1363, - 1577, 1578, 518, 1352, 504, 518, 518, 754, 518, 518, - 1587, 514, 514, 2017, 164, 454, 3374, 2021, 518, 480, - 359, 3044, 454, 409, 1601, 3375, 511, 512, 513, 514, - 753, 345, 3194, 1456, 754, 753, 509, 510, 2473, 2474, - 2475, 2476, 3367, 504, 447, 805, 2050, 794, 509, 510, - 389, 3213, 2952, 266, 2899, 1632, 173, 2025, 805, 812, - 2960, 468, 423, 178, 425, 812, 511, 512, 513, 514, - 384, 119, 748, 2486, 33, 162, 505, 506, 507, 794, - 509, 510, 511, 512, 513, 514, 472, 888, 203, 3038, - 805, 2777, 857, 1978, 841, 842, 513, 812, 405, 857, - 59, 408, 794, 520, 451, 419, 4, 860, 321, 203, - 1517, 9, 482, 805, 539, 916, 3459, 457, 865, 1801, - 812, 3166, 272, 3168, 2905, 878, 241, 521, 1877, 1811, - 1537, 507, 1814, 805, 504, 2020, 5, 875, 875, 875, - 875, 1023, 875, 863, 520, 875, 875, 1029, 3473, 4, - 275, 238, 875, 522, 9, 280, 470, 875, 875, 207, - 2490, 1796, 875, 3045, 1571, 912, 913, 3498, 245, 916, - 917, 518, 245, 3516, 480, 2861, 245, 3498, 518, 2178, - 295, 468, 106, 805, 2692, 1652, 2694, 866, 2811, 275, - 866, 2814, 309, 2816, 843, 844, 59, 846, 504, 848, - 287, 509, 510, 511, 512, 513, 514, 509, 510, 511, - 512, 513, 514, 1988, 339, 1829, 1830, 1831, 5, 875, - 875, 1769, 969, 875, 875, 273, 1855, 275, 875, 1911, - 3327, 1893, 3329, 980, 341, 1897, 3259, 875, 1900, 875, - 987, 988, 875, 3288, 178, 2532, 993, 875, 1796, 996, - 997, 875, 999, 1000, 1001, 1002, 3196, 875, 1018, 3584, - 983, 875, 2559, 132, 794, 983, 1902, 1911, 1816, 1016, - 935, 1018, 875, 1821, 875, 805, 875, 875, 395, 373, - 1027, 875, 812, 875, 875, 875, 518, 875, 517, 26, - 384, 160, 2471, 3176, 523, 32, 373, 1044, 1045, 1046, - 373, 1016, 2452, 1018, 373, 178, 3403, 241, 423, 172, - 425, 2194, 1027, 2196, 108, 189, 190, 259, 260, 1066, - 457, 1578, 40, 82, 1016, 419, 1018, 251, 753, 754, - 1587, 518, 25, 448, 93, 1027, 451, 261, 1085, 132, - 1807, 1101, 60, 2601, 1016, 1812, 1018, 2302, 82, 1096, - 1097, 1098, 4, 1100, 1101, 1027, 1103, 9, 1618, 93, - 516, 2329, 518, 2248, 520, 2873, 2370, 160, 241, 794, - 162, 1103, 355, 482, 451, 167, 470, 380, 451, 482, - 805, 518, 451, 3425, 3426, 259, 260, 812, 106, 1136, - 2677, 132, 380, 517, 1016, 504, 1018, 1974, 3084, 523, - 137, 504, 3342, 71, 72, 1027, 275, 1154, 1155, 518, - 480, 280, 482, 2310, 26, 518, 285, 516, 203, 160, - 32, 520, 115, 1188, 1189, 423, 1191, 425, 1181, 37, - 1188, 1189, 857, 1191, 516, 3477, 378, 379, 520, 373, - 516, 518, 252, 1190, 520, 518, 238, 1194, 1195, 518, - 875, 1911, 315, 316, 317, 436, 162, 1204, 1205, 1206, - 470, 167, 1209, 2184, 419, 1940, 1941, 1942, 1943, 1944, - 1945, 377, 2802, 1948, 1949, 1950, 1951, 1952, 1953, 1954, - 1955, 1956, 1957, 1230, 202, 2062, 1016, 280, 1018, 423, - 2377, 425, 285, 1246, 227, 287, 2383, 1027, 1174, 2284, - 8, 2286, 2506, 11, 378, 379, 519, 15, 16, 522, - 380, 19, 20, 21, 368, 369, 227, 451, 1265, 382, - 423, 518, 425, 8, 174, 137, 11, 1274, 368, 369, - 15, 16, 238, 251, 275, 368, 369, 2838, 46, 280, - 273, 13, 14, 261, 285, 53, 423, 518, 425, 345, - 423, 1298, 425, 13, 14, 273, 419, 294, 983, 172, - 516, 46, 273, 2140, 520, 173, 1918, 523, 53, 438, - 1922, 518, 80, 1925, 1321, 2189, 519, 167, 451, 522, - 449, 287, 1320, 1320, 1320, 1320, 518, 305, 384, 452, - 1337, 1016, 2780, 1018, 1028, 80, 246, 518, 1032, 1346, - 463, 209, 1027, 2488, 518, 1337, 1014, 2492, 26, 13, - 14, 1019, 1020, 1021, 32, 523, 1363, 225, 2905, 2281, - 357, 2283, 518, 419, 828, 829, 830, 235, 1036, 833, - 341, 519, 1040, 1380, 522, 518, 3576, 1062, 1385, 1362, - 2643, 359, 2645, 1363, 1362, 438, 511, 519, 1380, 1074, - 522, 1448, 389, 1450, 1451, 518, 449, 518, 82, 392, - 2135, 2136, 880, 3561, 882, 3563, 384, 519, 519, 177, - 522, 522, 3528, 2677, 470, 518, 1101, 1353, 2253, 1355, - 519, 392, 294, 522, 108, 403, 194, 3543, 1435, 1436, - 519, 199, 177, 522, 1441, 345, 1443, 438, 518, 2356, - 504, 1448, 1449, 1450, 1451, 2660, 3604, 518, 449, 194, - 843, 844, 2659, 846, 199, 848, 1463, 1464, 224, 137, - 501, 454, 520, 460, 290, 1472, 2691, 1474, 1443, 237, - 1477, 501, 2644, 147, 384, 1482, 519, 1484, 1485, 522, - 1487, 353, 3598, 454, 1491, 357, 519, 3603, 162, 522, - 174, 1443, 237, 167, 2537, 2538, 364, 1472, 171, 1474, - 522, 2708, 1477, 1188, 1189, 519, 1191, 1482, 522, 419, - 1485, 2658, 1487, 2660, 518, 383, 1491, 389, 172, 203, - 1472, 519, 1474, 519, 292, 1477, 522, 519, 519, 519, - 1482, 522, 522, 1485, 519, 1487, 519, 522, 1545, 1491, - 1472, 519, 1474, 519, 218, 1477, 522, 292, 13, 14, - 1482, 295, 3320, 1485, 3322, 1487, 13, 14, 519, 1491, - 470, 522, 246, 2544, 238, 13, 14, 59, 2405, 519, - 1577, 1578, 522, 2514, 2515, 2516, 13, 14, 2514, 1586, - 1587, 1574, 2514, 2515, 1574, 1574, 2513, 1594, 460, 518, - 1472, 1574, 1474, 420, 1601, 1477, 1574, 1574, 501, 519, - 1482, 1574, 522, 1485, 519, 1487, 224, 522, 152, 1491, - 353, 5, 519, 287, 519, 522, 294, 522, 13, 14, - 1627, 1628, 296, 152, 1685, 1632, 394, 519, 1635, 519, - 522, 152, 522, 1640, 1641, 1642, 1643, 1644, 1645, 1646, - 1647, 1648, 1649, 152, 26, 152, 1653, 1654, 1655, 394, - 32, 1658, 40, 1443, 419, 1662, 519, 1649, 1665, 1666, - 1667, 1668, 1669, 1670, 1671, 1672, 1673, 519, 40, 1676, - 522, 2398, 13, 14, 518, 353, 1683, 1362, 1685, 357, - 1655, 275, 1472, 470, 1474, 89, 2406, 1477, 3330, 373, - 3237, 519, 1482, 152, 522, 1485, 1703, 1487, 1723, 519, - 384, 1491, 522, 37, 2968, 1723, 13, 14, 484, 26, - 6, 389, 152, 519, 10, 32, 522, 2610, 520, 1726, - 519, 1701, 18, 522, 519, 519, 519, 522, 522, 522, - 1737, 1738, 126, 127, 502, 419, 32, 505, 506, 507, - 36, 509, 510, 511, 512, 513, 514, 2919, 290, 519, - 519, 2966, 522, 522, 152, 137, 152, 502, 442, 178, - 519, 368, 369, 522, 509, 510, 511, 512, 513, 514, - 1777, 355, 519, 447, 26, 522, 13, 14, 172, 1786, - 32, 1788, 460, 431, 203, 518, 470, 1472, 518, 1474, - 13, 14, 1477, 518, 1786, 519, 1788, 1482, 2633, 26, - 1485, 8, 1487, 13, 14, 32, 1491, 518, 15, 16, - 421, 3002, 19, 20, 21, 13, 14, 3042, 13, 14, - 137, 1828, 241, 147, 2698, 2742, 1833, 13, 14, 1836, - 1837, 2720, 13, 14, 2756, 788, 1772, 220, 162, 173, - 225, 2576, 2577, 167, 13, 14, 1782, 37, 1784, 300, - 3526, 1787, 42, 518, 3530, 13, 14, 1793, 225, 1795, - 13, 14, 225, 3127, 297, 2874, 518, 820, 40, 3279, - 1877, 236, 1808, 13, 14, 209, 295, 1813, 13, 14, - 518, 1817, 1818, 1819, 1820, 137, 1822, 1823, 1895, 1574, - 5, 225, 845, 5, 218, 1902, 1903, 13, 14, 518, - 1873, 235, 13, 14, 1911, 13, 14, 263, 264, 3585, - 137, 101, 294, 325, 238, 378, 379, 462, 463, 518, - 1927, 315, 316, 317, 1931, 1932, 518, 1934, 174, 2388, - 2389, 518, 1939, 1940, 1941, 1942, 1943, 1944, 1945, 5, - 893, 1948, 1949, 1950, 1951, 1952, 1953, 1954, 1955, 1956, - 1957, 3498, 3538, 3539, 373, 5, 1963, 1964, 3570, 3571, - 1967, 518, 1969, 287, 1154, 1155, 5, 1974, 518, 1976, - 1655, 353, 296, 3237, 5, 357, 9, 294, 2260, 2261, - 518, 518, 481, 173, 302, 104, 522, 522, 382, 519, - 220, 1998, 40, 167, 287, 285, 2003, 389, 2005, 393, - 246, 167, 2009, 59, 423, 236, 425, 389, 518, 431, - 2017, 93, 518, 431, 2021, 2957, 2023, 522, 2025, 209, - 2027, 415, 3432, 442, 59, 419, 431, 980, 2003, 448, - 364, 59, 451, 266, 2009, 225, 353, 990, 1723, 2774, - 357, 3248, 294, 2050, 3483, 235, 108, 2969, 2970, 383, - 431, 2003, 523, 519, 222, 2062, 2063, 2009, 452, 480, - 431, 431, 152, 100, 3474, 380, 275, 294, 199, 463, - 275, 2003, 389, 275, 518, 40, 275, 2009, 460, 269, - 2807, 275, 518, 152, 172, 292, 480, 13, 520, 519, - 519, 172, 519, 2100, 519, 519, 522, 2104, 518, 345, - 290, 353, 2109, 2110, 519, 357, 519, 225, 477, 519, - 504, 225, 282, 3523, 522, 282, 518, 518, 3099, 467, - 2140, 2003, 476, 447, 518, 315, 353, 2009, 2135, 2136, - 357, 520, 322, 2140, 518, 39, 9, 389, 384, 3364, - 37, 518, 518, 460, 518, 42, 429, 520, 429, 2156, - 518, 11, 2159, 2160, 2161, 178, 518, 1110, 3303, 518, - 517, 522, 389, 355, 528, 523, 172, 1120, 429, 522, - 2177, 2178, 518, 419, 364, 280, 1861, 2184, 431, 181, - 2187, 163, 172, 522, 519, 2160, 457, 266, 1873, 1142, - 522, 218, 516, 383, 40, 519, 520, 2204, 1151, 392, - 291, 227, 522, 313, 101, 2940, 313, 181, 460, 1046, - 2217, 2938, 2187, 2003, 60, 220, 522, 519, 241, 2009, - 151, 518, 275, 227, 470, 296, 227, 2234, 2235, 2204, - 147, 334, 470, 460, 3498, 2187, 288, 152, 518, 3, - 518, 172, 518, 152, 2251, 162, 2253, 152, 480, 152, - 167, 152, 2204, 522, 522, 2187, 40, 275, 8, 2266, - 106, 11, 452, 2199, 3, 15, 16, 457, 290, 19, - 20, 21, 2204, 290, 40, 11, 173, 2284, 2285, 2286, - 59, 172, 40, 167, 519, 519, 3501, 181, 167, 3, - 519, 314, 2284, 2285, 2286, 519, 518, 3214, 505, 506, - 507, 218, 509, 510, 511, 512, 513, 514, 1046, 315, - 316, 317, 209, 39, 1151, 518, 2323, 518, 2003, 3, - 516, 238, 2329, 520, 2009, 516, 501, 431, 225, 431, - 176, 431, 431, 517, 519, 522, 519, 519, 235, 980, - 528, 2361, 519, 519, 501, 353, 519, 148, 3083, 520, - 373, 501, 2350, 2350, 2350, 2350, 202, 380, 2365, 519, - 3080, 172, 518, 2370, 519, 519, 431, 518, 155, 518, - 287, 518, 269, 2365, 250, 518, 382, 40, 59, 296, - 477, 522, 507, 2390, 315, 316, 317, 454, 522, 291, - 503, 291, 2912, 1230, 244, 59, 266, 2187, 2405, 2406, - 423, 59, 425, 275, 152, 251, 469, 2414, 203, 518, - 431, 152, 152, 419, 2204, 261, 431, 431, 315, 431, - 431, 282, 2414, 282, 519, 322, 1379, 273, 451, 518, - 40, 518, 355, 519, 288, 290, 480, 522, 40, 3332, - 152, 280, 519, 527, 2380, 2452, 452, 172, 518, 199, - 518, 382, 3289, 59, 3291, 2140, 186, 463, 519, 305, - 519, 519, 167, 80, 519, 516, 3301, 364, 143, 172, - 519, 199, 222, 518, 480, 2160, 522, 2452, 519, 1120, - 522, 519, 8, 2490, 1321, 11, 383, 519, 419, 15, - 16, 2176, 1230, 19, 20, 21, 301, 522, 504, 2506, - 2452, 291, 2187, 523, 3304, 2518, 3306, 181, 3489, 518, - 1151, 518, 518, 359, 361, 152, 2523, 3434, 518, 2204, - 519, 452, 2529, 2530, 2544, 519, 2587, 522, 519, 176, - 447, 442, 463, 519, 519, 519, 519, 2544, 384, 520, - 518, 37, 292, 518, 86, 522, 42, 518, 3443, 480, - 3424, 40, 40, 2560, 40, 452, 2563, 403, 2565, 457, - 522, 172, 2582, 518, 199, 2572, 2573, 519, 519, 2576, - 2577, 151, 479, 504, 2581, 2582, 519, 517, 517, 290, - 522, 2588, 3417, 1321, 519, 519, 519, 518, 463, 519, - 1231, 507, 172, 1234, 1235, 59, 2603, 519, 519, 516, - 519, 519, 480, 520, 205, 101, 2613, 117, 2601, 40, - 518, 2601, 2601, 2633, 227, 7, 8, 88, 2601, 192, - 280, 13, 507, 2601, 2601, 280, 2633, 19, 2601, 431, - 520, 23, 520, 25, 2607, 74, 517, 29, 30, 31, - 520, 80, 34, 520, 40, 37, 38, 275, 431, 41, - 517, 520, 44, 45, 93, 520, 520, 520, 520, 107, - 480, 519, 2452, 520, 520, 419, 519, 2674, 520, 520, - 2677, 2678, 520, 2680, 518, 520, 2361, 173, 117, 520, - 119, 519, 2674, 75, 76, 2692, 2678, 2694, 2680, 520, - 520, 520, 520, 520, 520, 520, 222, 520, 520, 520, - 2636, 520, 520, 2639, 520, 520, 520, 290, 1545, 101, - 518, 518, 9, 209, 354, 518, 108, 109, 110, 111, - 112, 2719, 2719, 2719, 2719, 518, 522, 1368, 1369, 225, - 2666, 2751, 336, 522, 519, 315, 316, 317, 59, 235, - 1693, 519, 2715, 199, 3471, 2681, 2682, 2683, 2684, 2685, - 2686, 2687, 2688, 2689, 2690, 505, 506, 507, 517, 509, - 510, 511, 512, 513, 514, 522, 292, 2774, 207, 192, - 2777, 2744, 519, 269, 462, 91, 522, 26, 347, 2799, - 40, 519, 152, 32, 518, 520, 519, 2794, 2795, 124, - 152, 40, 2799, 40, 290, 2802, 519, 369, 369, 40, - 519, 518, 382, 1640, 40, 518, 522, 1545, 457, 518, - 310, 60, 1765, 1766, 518, 280, 249, 191, 457, 315, - 442, 518, 2829, 74, 293, 172, 322, 80, 74, 519, - 9, 371, 519, 518, 517, 59, 275, 519, 517, 419, - 133, 280, 2849, 93, 273, 507, 290, 442, 2855, 2856, - 40, 518, 293, 2860, 2861, 293, 205, 106, 2865, 2544, - 40, 2868, 2869, 519, 518, 462, 2873, 2874, 364, 519, - 2877, 1824, 452, 519, 2881, 2895, 3396, 290, 290, 122, - 60, 2888, 389, 463, 454, 1838, 1839, 383, 137, 519, - 329, 368, 148, 25, 36, 368, 298, 2582, 1794, 875, - 480, 2279, 1640, 2674, 2661, 3334, 2881, 2611, 347, 3474, - 3428, 3575, 2962, 1902, 2393, 852, 2601, 3449, 3553, 3207, - 3502, 3511, 2607, 3546, 504, 2932, 106, 3265, 1217, 2881, - 2285, 2272, 2733, 2940, 3500, 2653, 3509, 2269, 518, 2680, - 1777, 3497, 1345, 2388, 2349, 2389, 2414, 3080, 2633, 2881, - 2251, 1592, 2959, 202, 2710, 1174, 452, 304, 1911, 1762, - 2471, 2968, 2217, 1604, 1917, 1606, 1318, 3483, 315, 316, - 317, 1197, 1015, 1198, 2234, 1015, 1726, 3405, 3293, 505, - 506, 507, 1761, 509, 510, 511, 512, 513, 514, 1200, - 23, 2204, 2015, 1634, 117, 3002, 3122, 2452, 2451, 2881, - 2802, 2498, 251, 2939, 992, 3228, 2030, 2968, 3409, 448, - 990, 990, 261, 1911, 1911, 3408, 1911, 990, 457, 2111, - 990, 990, 202, 990, 273, 2530, 990, 990, 2064, 990, - 2715, 2218, 2160, 2850, 2113, 382, 1464, 3044, 2157, 1777, - 2556, 2852, 2888, 2601, 3394, 294, 789, 1839, 2023, 172, - 1363, 893, 3044, 2612, 1701, 2322, 305, 1702, -1, 2744, - -1, -1, -1, -1, -1, 3072, 2751, -1, -1, -1, - -1, 251, 419, 3080, 1254, -1, 3083, 3084, -1, 3099, - -1, 261, -1, -1, -1, -1, 3059, -1, -1, -1, - 1927, 2881, 3099, 273, -1, -1, 1737, 1738, 178, -1, - -1, -1, 1939, -1, 353, 452, -1, -1, 357, -1, - 359, -1, -1, -1, 2799, -1, 463, -1, -1, -1, - 3127, -1, -1, 203, -1, 305, 3133, -1, -1, -1, - -1, -1, 1969, 480, -1, 384, -1, -1, -1, 1976, - 389, -1, -1, 3150, 3151, -1, -1, 3154, 540, 3156, - -1, -1, -1, 545, 403, 8, 548, 504, 11, -1, - 1801, 241, 15, 16, 556, -1, 19, 20, 21, -1, - 1811, 518, -1, 1814, 3181, 8, -1, -1, 11, 359, - 2017, 304, 15, 16, 2021, -1, 19, 20, 21, 1927, - 2027, -1, 315, 316, 317, -1, 2881, -1, 3205, -1, - -1, 1939, -1, 36, 384, -1, -1, -1, -1, -1, - 2895, 460, -1, 2050, -1, 295, -1, -1, -1, -1, - -1, -1, -1, 403, -1, -1, -1, -1, -1, -1, - 3237, 1969, -1, -1, 314, -1, -1, -1, 1976, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 8, -1, 3259, 11, -1, -1, -1, 15, 16, 382, - -1, 19, 20, 21, -1, -1, -1, 3259, -1, -1, - 1911, -1, 3279, -1, -1, -1, -1, -1, 36, 2017, - 3216, 3254, 3289, 2021, 3291, -1, 3293, -1, -1, 2027, - 3297, -1, 3299, 373, 3301, -1, 419, -1, -1, -1, - 380, -1, 3238, 3239, 3279, -1, -1, -1, 3315, -1, - -1, -1, 2050, 3320, -1, 3322, -1, -1, -1, -1, - -1, -1, -1, 3330, -1, -1, 3262, 3279, -1, 452, - -1, -1, -1, -1, -1, -1, 3343, -1, 2291, -1, - 463, 3348, -1, 423, -1, 425, 199, -1, -1, -1, - -1, 3343, -1, -1, 746, 747, 748, 480, 3331, -1, - 3333, -1, 442, -1, -1, -1, -1, -1, 448, 222, - -1, 451, -1, -1, 3059, -1, -1, -1, -1, -1, - -1, 504, -1, -1, -1, -1, -1, -1, 3395, 222, - 2343, -1, -1, 2034, -1, 518, 788, 789, 3405, -1, - 3373, -1, 794, -1, 796, -1, -1, -1, 2361, -1, - 3417, -1, -1, 805, 3099, -1, 3389, 809, 810, -1, - 812, -1, -1, 815, 816, 3432, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 828, 829, 830, 292, - -1, 833, -1, 3450, -1, -1, -1, -1, -1, 841, - 842, 843, 844, 2406, 846, -1, 848, 3432, -1, 292, - -1, -1, -1, 2416, 222, 2418, -1, 3474, 860, 2422, - -1, 2424, -1, -1, 866, -1, -1, -1, -1, -1, - 3432, -1, 3489, -1, -1, -1, 878, -1, -1, 3279, - 98, 3498, -1, 3500, -1, -1, -1, -1, -1, 3474, - 892, 893, -1, -1, -1, -1, -1, -1, 3500, -1, - -1, -1, -1, -1, -1, -1, 3523, -1, 126, 127, - -1, -1, 3474, -1, -1, -1, -1, -1, -1, 997, - 3537, 3538, 3539, 2370, 292, 927, 928, -1, -1, -1, - -1, -1, 3515, -1, -1, -1, -1, 939, 3523, -1, - 2191, 943, 944, 945, 946, -1, -1, 3564, 3494, -1, - -1, -1, -1, -1, 172, -1, -1, 959, 3541, 3254, - -1, 3523, -1, -1, 37, -1, -1, -1, -1, 42, - -1, -1, -1, 2224, 2225, -1, -1, -1, -1, -1, - 3275, -1, -1, -1, -1, -1, -1, -1, 3605, 991, - 992, -1, 994, -1, -1, 997, -1, -1, -1, -1, - -1, 1003, 1004, -1, -1, -1, -1, -1, 1010, -1, - -1, -1, -1, -1, 1016, -1, 1018, -1, -1, 0, - -1, -1, 2370, -1, -1, 1027, -1, -1, 101, -1, - -1, -1, 3432, -1, -1, 1037, 3331, -1, 3333, -1, + 7, 521, 46, 0, 0, 0, 0, 0, 0, 16, + 0, 0, 841, 888, 0, 746, 23, 0, 73, 903, + 815, 1443, 930, 7, 914, 999, 38, 0, 1256, 1459, + 1242, 1045, 1230, 965, 20, 754, 935, 20, 1720, 23, + 16, 1217, 1244, 1683, 1093, 7, 1175, 2221, 20, 990, + 1495, 1828, 990, 1612, 1836, 1321, 865, 1655, 1574, 77, + 2280, 23, 990, 980, 37, 1298, 1600, 1222, 75, 76, + 2029, 969, 2368, 23, 1210, 990, 2211, 980, 0, 77, + 17, 1219, 0, 2717, 0, 2190, 0, 2192, 1636, 1637, + 0, 75, 76, 0, 0, 2680, 0, 1140, 1346, 111, + 0, 0, 1145, 45, 0, 2276, 903, 0, 905, 1247, + 907, 2715, 0, 75, 76, 2680, 0, 34, 1008, 2156, + 2740, 2210, 754, 753, 747, 75, 76, 1101, 101, 810, + 0, 2733, 0, 0, 2547, 816, 2348, 0, 0, 5, + 1687, 0, 0, 75, 76, 2634, 1853, 13, 14, 2638, + 1850, 0, 5, 2030, 9, 0, 1738, 5, 9, 0, + 1967, 4, 1740, 1067, 1068, 2847, 9, 10, 63, 0, + 5, 3062, 5, 55, 0, 5, 9, 778, 2356, 988, + 1084, 45, 63, 5, 2360, 2360, 2354, 5, 80, 74, + 5, 5, 26, 5, 9, 5, 991, 1849, 2369, 13, + 14, 139, 5, 5, 997, 5, 5, 5, 45, 5, + 5, 5, 5, 13, 14, 13, 14, 13, 14, 1655, + 173, 3, 4, 5, 122, 13, 14, 9, 13, 14, + 4, 107, 82, 23, 1151, 9, 119, 4, 82, 860, + 3048, 11, 9, 93, 883, 147, 16, 1046, 172, 93, + 122, 1265, 2423, 2424, 30, 2426, 883, 3065, 90, 100, + 1274, 980, 38, 11, 2003, 2004, 104, 1157, 16, 3238, + 191, 40, 63, 3, 100, 2014, 1184, 63, 124, 2018, + 122, 172, 288, 2902, 169, 75, 76, 807, 11, 2493, + 172, 1100, 15, 16, 172, 296, 3018, 129, 46, 1071, + 5, 107, 173, 137, 34, 35, 53, 2883, 290, 2885, + 291, 992, 245, 805, 1231, 1087, 218, 1234, 1235, 2596, + 117, 2598, 291, 1004, 184, 1995, 1996, 1997, 107, 1458, + 5, 132, 80, 296, 854, 117, 245, 193, 30, 193, + 3370, 213, 119, 181, 11, 181, 38, 1545, 15, 16, + 276, 106, 1151, 983, 64, 3, 40, 5, 368, 166, + 382, 313, 391, 3400, 74, 3167, 1495, 3169, 345, 40, + 2475, 213, 3433, 41, 1640, 162, 1205, 1206, 279, 46, + 13, 14, 2650, 30, 3476, 119, 164, 108, 83, 30, + 482, 38, 117, 457, 296, 122, 3328, 480, 3330, 30, + 1209, 11, 2179, 482, 3565, 409, 120, 384, 507, 148, + 137, 1204, 504, 80, 794, 1937, 82, 369, 3003, 518, + 359, 504, 120, 3057, 1332, 504, 518, 93, 1303, 2649, + 177, 1230, 812, 3463, 3068, 273, 3466, 219, 309, 518, + 373, 171, 419, 173, 329, 3606, 1968, 194, 2622, 290, + 389, 238, 199, 148, 518, 3059, 3264, 132, 126, 241, + 294, 200, 1361, 3524, 290, 360, 191, 273, 472, 3561, + 80, 192, 3404, 207, 275, 2646, 308, 2648, 3369, 360, + 340, 195, 273, 280, 285, 160, 2754, 3289, 3525, 518, + 237, 132, 176, 470, 272, 396, 251, 195, 2535, 355, + 522, 132, 1551, 280, 358, 176, 261, 431, 518, 369, + 2787, 1777, 518, 2948, 3236, 3091, 485, 324, 451, 507, + 361, 522, 1321, 357, 395, 359, 1018, 1023, 454, 3559, + 3499, 241, 520, 1029, 167, 361, 518, 518, 476, 273, + 431, 275, 451, 419, 2103, 447, 2328, 2329, 2330, 11, + 275, 2729, 416, 15, 16, 389, 454, 178, 2726, 522, + 1181, 513, 3181, 448, 2162, 518, 539, 1168, 1207, 360, + 2746, 2746, 13, 3464, 360, 280, 459, 2022, 19, 416, + 1207, 431, 454, 507, 46, 518, 593, 431, 1108, 30, + 428, 469, 424, 2764, 373, 1771, 520, 518, 389, 2803, + 275, 328, 1835, 44, 45, 280, 1510, 1511, 513, 518, + 285, 457, 454, 482, 1345, 520, 2575, 593, 80, 1350, + 241, 457, 2156, 399, 516, 1356, 2433, 522, 520, 290, + 3312, 1535, 467, 11, 1463, 504, 518, 15, 16, 480, + 1449, 522, 1435, 1436, 1363, 2227, 2194, 394, 1441, 1897, + 2228, 3253, 518, 3238, 480, 1484, 108, 3465, 509, 510, + 132, 527, 517, 1929, 2371, 518, 2366, 2214, 109, 1871, + 518, 1685, 521, 3238, 527, 1941, 521, 522, 519, 482, + 521, 524, 525, 518, 1912, 518, 2220, 518, 518, 482, + 521, 1595, 1596, 519, 516, 521, 518, 3186, 520, 2919, + 518, 504, 3191, 518, 518, 1971, 518, 399, 518, 2361, + 754, 504, 1978, 480, 2926, 518, 518, 164, 518, 518, + 518, 3134, 518, 518, 518, 518, 2162, 509, 510, 1352, + 518, 1363, 1362, 518, 3368, 509, 510, 504, 468, 1629, + 1630, 1631, 509, 510, 514, 1517, 1545, 754, 11, 3045, + 2489, 520, 399, 2019, 33, 457, 3376, 2023, 406, 407, + 3195, 805, 162, 438, 75, 1537, 514, 753, 1577, 1578, + 753, 266, 275, 3375, 449, 1456, 227, 280, 1587, 3214, + 59, 433, 754, 46, 231, 149, 2052, 794, 511, 512, + 513, 514, 1601, 1448, 2027, 1450, 1451, 132, 805, 1571, + 812, 997, 423, 345, 425, 812, 2476, 2477, 2478, 2479, + 794, 2900, 26, 285, 26, 2597, 518, 80, 32, 2778, + 32, 805, 273, 1632, 162, 160, 321, 108, 812, 167, + 451, 483, 794, 888, 841, 842, 339, 201, 238, 857, + 3474, 1640, 384, 805, 511, 512, 513, 514, 860, 250, + 812, 1980, 3426, 3427, 2953, 805, 3460, 513, 865, 857, + 82, 916, 2961, 162, 520, 1879, 878, 1578, 167, 2906, + 418, 93, 419, 805, 275, 3046, 1587, 419, 875, 875, + 875, 875, 875, 875, 1801, 875, 875, 287, 1681, 875, + 341, 863, 875, 2022, 1811, 2493, 519, 1814, 227, 522, + 238, 518, 875, 2862, 3478, 912, 913, 5, 456, 916, + 917, 517, 1796, 3517, 3499, 516, 26, 523, 2695, 520, + 2697, 1652, 32, 137, 866, 137, 843, 844, 470, 846, + 517, 848, 2180, 1726, 3499, 2812, 523, 4, 2815, 238, + 2817, 392, 9, 4, 273, 280, 0, 1990, 9, 287, + 285, 3585, 521, 875, 1829, 1830, 1831, 875, 1857, 875, + 522, 875, 969, 1895, 3260, 875, 468, 1899, 875, 875, + 1902, 875, 1769, 980, 1018, 875, 875, 3197, 1777, 875, + 987, 988, 875, 245, 13, 14, 993, 875, 287, 996, + 997, 875, 999, 1000, 1001, 1002, 1913, 983, 935, 1796, + 983, 2535, 275, 454, 794, 875, 1904, 875, 875, 1016, + 1913, 1018, 875, 875, 2562, 805, 875, 875, 4, 1816, + 1027, 214, 812, 9, 1821, 5, 203, 137, 126, 127, + 518, 516, 1016, 2455, 1018, 520, 516, 1044, 1045, 1046, + 520, 1028, 3177, 1027, 2474, 1032, 341, 509, 510, 511, + 512, 513, 514, 518, 1016, 519, 1018, 1101, 522, 1066, + 2196, 519, 2198, 392, 522, 1027, 1016, 245, 1018, 108, + 843, 844, 37, 846, 172, 848, 1807, 1027, 1085, 355, + 294, 1812, 294, 516, 1016, 518, 1018, 520, 2604, 1096, + 1097, 1098, 380, 1100, 1101, 1027, 1103, 2874, 1618, 71, + 72, 2334, 2304, 438, 203, 519, 516, 2373, 522, 380, + 520, 373, 74, 523, 449, 556, 132, 828, 829, 830, + 252, 2250, 833, 3343, 436, 454, 3085, 1103, 419, 1136, + 1929, 509, 510, 511, 512, 513, 514, 245, 423, 353, + 425, 353, 1941, 357, 160, 357, 2680, 1154, 1155, 1942, + 1943, 1944, 1945, 1946, 1947, 117, 470, 1950, 1951, 1952, + 1953, 1954, 1955, 1956, 1957, 1958, 1959, 1976, 377, 1181, + 1188, 1189, 1971, 1191, 2312, 389, 423, 389, 425, 1978, + 167, 189, 190, 1190, 294, 380, 30, 1194, 1195, 451, + 1188, 1189, 518, 1191, 1913, 373, 373, 1204, 1205, 1206, + 178, 245, 1209, 245, 172, 2803, 519, 384, 173, 522, + 511, 519, 2186, 174, 522, 13, 14, 315, 316, 317, + 2019, 13, 14, 1230, 2023, 2380, 1016, 523, 1018, 1920, + 2029, 2386, 519, 1924, 1246, 522, 1927, 1027, 518, 1435, + 1436, 85, 419, 2509, 209, 1441, 460, 357, 460, 518, + 94, 259, 260, 2052, 518, 2064, 518, 3039, 1265, 275, + 225, 13, 14, 241, 280, 373, 26, 1274, 519, 285, + 235, 522, 32, 451, 118, 519, 13, 14, 522, 389, + 2839, 26, 13, 14, 382, 246, 26, 32, 516, 518, + 518, 1298, 32, 470, 518, 393, 519, 8, 519, 522, + 11, 522, 504, 519, 15, 16, 522, 748, 19, 20, + 21, 224, 519, 275, 1321, 522, 2191, 415, 280, 519, + 518, 419, 522, 25, 1320, 1320, 1320, 1320, 518, 373, + 1337, 373, 518, 2142, 259, 260, 2781, 501, 519, 1346, + 518, 522, 518, 451, 2137, 2138, 480, 191, 482, 59, + 460, 2283, 519, 2285, 452, 522, 1363, 3577, 26, 518, + 204, 1337, 2491, 518, 32, 463, 2495, 329, 13, 14, + 378, 379, 2906, 1380, 13, 14, 1362, 137, 1385, 1362, + 519, 147, 480, 522, 345, 347, 519, 290, 3562, 522, + 3564, 1363, 137, 13, 14, 373, 162, 137, 520, 364, + 519, 167, 519, 522, 1380, 522, 504, 451, 519, 451, + 518, 522, 519, 115, 2680, 522, 519, 501, 383, 522, + 518, 171, 438, 384, 3529, 866, 2255, 519, 1435, 1436, + 522, 3605, 519, 449, 1441, 522, 1443, 519, 518, 3544, + 522, 1448, 1449, 1450, 1451, 423, 519, 425, 522, 522, + 2662, 2359, 218, 378, 379, 519, 1463, 1464, 419, 1443, + 2253, 2663, 172, 13, 14, 1472, 2694, 1474, 519, 137, + 1477, 2647, 238, 451, 518, 1482, 518, 1484, 1485, 519, + 1487, 1443, 522, 423, 1491, 425, 448, 423, 1472, 425, + 1474, 2540, 2541, 1477, 3599, 457, 519, 2709, 1482, 3604, + 172, 1485, 519, 1487, 295, 522, 2661, 1491, 2663, 470, + 1472, 222, 1474, 519, 519, 1477, 522, 522, 13, 14, + 1482, 287, 1472, 1485, 1474, 1487, 59, 1477, 519, 1491, + 296, 522, 1482, 518, 294, 1485, 420, 1487, 1545, 37, + 1472, 1491, 1474, 501, 3321, 1477, 3323, 224, 519, 294, + 1482, 522, 152, 1485, 294, 1487, 2286, 353, 2288, 1491, + 519, 405, 519, 522, 408, 522, 519, 13, 14, 522, + 1577, 1578, 40, 2547, 2373, 152, 2517, 1574, 2516, 1586, + 1587, 292, 1574, 152, 1574, 1574, 152, 1594, 1574, 2517, + 2518, 1574, 152, 353, 1601, 419, 174, 357, 2646, 2408, + 2648, 1574, 2517, 2518, 2519, 315, 316, 317, 353, 13, + 14, 8, 357, 353, 11, 13, 14, 357, 15, 16, + 1627, 1628, 19, 20, 21, 1632, 294, 519, 1635, 389, + 1685, 13, 14, 1640, 1641, 1642, 1643, 1644, 1645, 1646, + 1647, 1648, 1649, 880, 389, 882, 1653, 1654, 1655, 389, + 518, 1658, 275, 1443, 40, 1662, 13, 14, 1665, 1666, + 1667, 1668, 1669, 1670, 1671, 1672, 1673, 470, 246, 1676, + 2401, 1655, 382, 1649, 89, 173, 1683, 152, 1685, 13, + 14, 447, 1472, 484, 1474, 353, 152, 1477, 520, 357, + 2409, 3331, 1482, 13, 14, 1485, 1703, 1487, 1046, 152, + 460, 1491, 147, 2969, 3238, 1723, 13, 14, 178, 419, + 2509, 209, 13, 14, 152, 460, 290, 162, 355, 1726, + 460, 389, 167, 2613, 431, 1723, 519, 225, 518, 1701, + 1737, 1738, 518, 1174, 13, 14, 518, 235, 13, 14, + 13, 14, 452, 518, 2920, 421, 1942, 1943, 1944, 1945, + 1946, 1947, 300, 463, 1950, 1951, 1952, 1953, 1954, 1955, + 1956, 1957, 1958, 1959, 225, 2967, 220, 345, 13, 14, + 1777, 241, 518, 218, 13, 14, 2575, 368, 369, 1786, + 518, 1788, 368, 369, 368, 369, 2579, 2580, 368, 369, + 263, 264, 460, 238, 505, 506, 507, 225, 509, 510, + 511, 512, 513, 514, 225, 3003, 384, 2636, 518, 297, + 1786, 1014, 1788, 378, 379, 3043, 1019, 1020, 1021, 462, + 463, 1828, 2721, 40, 40, 2757, 2701, 236, 1835, 2391, + 2392, 1838, 1839, 1036, 6, 2743, 518, 1040, 10, 3571, + 3572, 419, 287, 60, 314, 3527, 18, 3539, 3540, 3531, + 5, 296, 1154, 1155, 2262, 2263, 5, 518, 3280, 518, + 32, 2875, 3128, 325, 36, 518, 364, 518, 5, 5, + 518, 5, 1879, 5, 518, 481, 9, 518, 518, 302, + 522, 2680, 1230, 104, 522, 383, 519, 40, 220, 106, + 1897, 167, 470, 389, 287, 292, 167, 1904, 1905, 59, + 285, 236, 1875, 373, 3586, 518, 1913, 431, 518, 93, + 380, 522, 1353, 431, 1355, 59, 59, 431, 266, 431, + 108, 523, 1929, 222, 431, 431, 1933, 1934, 480, 1936, + 380, 100, 152, 275, 1941, 1942, 1943, 1944, 1945, 1946, + 1947, 2137, 2138, 1950, 1951, 1952, 1953, 1954, 1955, 1956, + 1957, 1958, 1959, 423, 275, 425, 199, 275, 1965, 1966, + 518, 40, 1969, 275, 1971, 3499, 275, 518, 82, 1976, + 152, 1978, 3238, 1321, 172, 520, 13, 519, 0, 2778, + 519, 451, 2775, 172, 519, 202, 522, 519, 519, 519, + 519, 518, 477, 2000, 108, 225, 519, 225, 2005, 282, + 2007, 282, 447, 518, 2011, 518, 522, 2800, 467, 520, + 518, 3433, 2019, 518, 518, 518, 2023, 26, 2025, 518, + 2027, 2005, 2029, 32, 39, 518, 520, 2011, 476, 9, + 429, 40, 11, 429, 251, 518, 355, 3249, 2970, 2971, + 517, 2958, 522, 2005, 261, 2052, 528, 523, 522, 2011, + 429, 60, 181, 3475, 3484, 2005, 273, 2064, 2065, 431, + 174, 2011, 280, 2862, 163, 172, 518, 522, 519, 457, + 218, 516, 266, 2005, 519, 520, 392, 2808, 100, 2011, + 522, 227, 291, 522, 313, 522, 788, 313, 305, 203, + 181, 518, 220, 519, 275, 2102, 227, 106, 2142, 2106, + 227, 296, 3524, 282, 2111, 2112, 282, 519, 505, 506, + 507, 334, 509, 510, 511, 512, 513, 514, 820, 470, + 288, 152, 3, 518, 518, 147, 3100, 518, 137, 152, + 2137, 2138, 246, 152, 152, 2142, 37, 3365, 152, 480, + 162, 42, 359, 845, 522, 167, 522, 40, 2941, 275, + 172, 2158, 290, 3, 2161, 2162, 2163, 997, 40, 181, + 290, 59, 172, 11, 186, 40, 167, 384, 181, 519, + 2969, 518, 2179, 2180, 519, 3304, 519, 167, 2162, 2186, + 519, 518, 2189, 3, 39, 518, 403, 3, 516, 516, + 431, 893, 517, 202, 431, 431, 218, 1545, 431, 2206, + 101, 353, 519, 501, 3003, 2189, 519, 522, 2939, 519, + 501, 40, 2219, 519, 528, 2005, 238, 520, 520, 519, + 148, 2011, 2206, 519, 519, 519, 519, 2189, 172, 2236, + 2237, 60, 501, 3499, 518, 431, 518, 155, 518, 2189, + 518, 518, 251, 250, 2206, 477, 2253, 40, 2255, 59, + 522, 507, 261, 503, 454, 291, 2206, 291, 522, 373, + 244, 2268, 59, 59, 273, 287, 266, 469, 290, 431, + 384, 275, 173, 178, 296, 152, 518, 106, 980, 2286, + 2287, 2288, 203, 152, 152, 294, 3085, 518, 990, 431, + 431, 3084, 1640, 40, 519, 355, 305, 519, 203, 518, + 3502, 288, 519, 480, 290, 419, 431, 3215, 209, 431, + 2286, 2287, 2288, 40, 336, 522, 152, 527, 2325, 280, + 2364, 172, 519, 59, 225, 518, 518, 2334, 442, 3128, + 186, 1772, 519, 519, 235, 167, 241, 80, 516, 361, + 143, 1782, 522, 1784, 353, 519, 1787, 176, 357, 519, + 359, 522, 1793, 519, 1795, 1195, 470, 2353, 2353, 2353, + 2353, 2368, 3081, 519, 1204, 199, 2373, 1808, 269, 519, + 172, 518, 1813, 202, 519, 384, 1817, 1818, 1819, 1820, + 389, 1822, 1823, 2579, 2580, 301, 2393, 361, 523, 290, + 295, 291, 2368, 2913, 403, 518, 181, 419, 522, 2189, + 519, 2408, 2409, 518, 152, 522, 519, 519, 1110, 314, + 2417, 176, 518, 442, 315, 519, 2206, 519, 1120, 519, + 518, 322, 251, 520, 518, 447, 519, 522, 518, 1777, + 40, 86, 261, 40, 40, 457, 457, 522, 172, 3238, + 1142, 2417, 518, 3333, 273, 519, 479, 519, 2455, 1151, + 199, 460, 519, 517, 517, 477, 522, 479, 480, 290, + 519, 519, 519, 364, 519, 463, 507, 59, 373, 519, + 519, 2455, 519, 3302, 519, 380, 305, 8, 480, 205, + 11, 3290, 383, 3292, 15, 16, 2493, 117, 19, 20, + 21, 40, 518, 2455, 516, 227, 192, 519, 520, 521, + 88, 280, 2509, 2547, 280, 431, 431, 3300, 520, 2521, + 3305, 519, 3307, 507, 520, 520, 3490, 520, 423, 2526, + 425, 520, 517, 520, 520, 2532, 2533, 3435, 520, 520, + 359, 520, 520, 40, 517, 2590, 275, 442, 520, 520, + 2547, 2585, 520, 448, 520, 520, 451, 520, 520, 520, + 3425, 452, 520, 520, 520, 384, 2563, 520, 520, 2566, + 3444, 2568, 520, 520, 520, 520, 520, 520, 2575, 2576, + 520, 519, 2579, 2580, 403, 107, 519, 2584, 2585, 2775, + 518, 1929, 518, 480, 2591, 290, 419, 518, 9, 3418, + 1046, 354, 2636, 1941, 518, 1435, 1436, 59, 518, 2606, + 522, 1441, 199, 336, 519, 522, 519, 2604, 517, 2616, + 522, 519, 2604, 192, 2604, 2604, 7, 8, 2604, 37, + 522, 2604, 13, 1971, 42, 462, 91, 519, 19, 2636, + 1978, 2604, 23, 347, 25, 518, 40, 2610, 29, 30, + 31, 152, 117, 34, 520, 519, 37, 38, 124, 152, + 41, 40, 519, 44, 45, 519, 172, 369, 369, 518, + 40, 518, 40, 457, 522, 2455, 518, 310, 199, 518, + 2677, 2019, 280, 2680, 2681, 2023, 2683, 1379, 249, 191, + 457, 2029, 442, 101, 75, 76, 178, 74, 2695, 293, + 2697, 222, 518, 74, 80, 74, 9, 172, 519, 80, + 3499, 2677, 519, 518, 2052, 2681, 371, 2683, 2752, 517, + 101, 203, 93, 519, 59, 507, 517, 108, 109, 110, + 111, 112, 93, 133, 2720, 2720, 2720, 2720, 273, 290, + 40, 518, 442, 293, 293, 518, 117, 519, 119, 519, + 462, 3472, 205, 2716, 519, 2941, 290, 290, 519, 241, + 389, 454, 122, 980, 368, 173, 2800, 25, 148, 36, + 2201, 292, 147, 181, 298, 368, 875, 2664, 2775, 1794, + 2281, 2778, 2745, 8, 1230, 3335, 11, 162, 3475, 3429, + 15, 16, 167, 2677, 19, 20, 21, 2614, 2795, 2796, + 3576, 209, 1904, 2800, 2963, 178, 2803, 2396, 852, 315, + 316, 317, 8, 295, 3450, 11, 3554, 225, 3208, 15, + 16, 3503, 3512, 19, 20, 21, 1217, 235, 3547, 3266, + 203, 2274, 2734, 2830, 2287, 3501, 207, 2656, 3510, 304, + 36, 2683, 2271, 218, 3498, 1345, 2391, 1318, 2392, 2352, + 315, 316, 317, 2850, 2417, 3081, 2711, 2253, 1174, 2856, + 2857, 269, 2896, 238, 2861, 2862, 1015, 1015, 241, 2866, + 2219, 40, 2869, 2870, 1762, 1321, 382, 2874, 2875, 1198, + 2474, 2878, 290, 1197, 3484, 2882, 2236, 3397, 1726, 3406, + 3294, 60, 2889, 1761, 23, 2206, 1726, 2017, 3084, 1200, + 2803, 3123, 2455, 1120, 275, 2454, 992, 315, 2882, 280, + 3229, 2501, 287, 419, 322, 2032, 2969, 382, 990, 990, + 990, 296, 295, 990, 1913, 990, 1913, 990, 1913, 990, + 2882, 990, 990, 3410, 1151, 3409, 2933, 106, 107, 2113, + 2533, 423, 2882, 425, 2941, 2162, 452, 2220, 117, 2159, + 2066, 2889, 2383, 2851, 419, 1464, 364, 463, 329, 2115, + 2882, 2559, 3395, 2960, 2604, 1841, 448, 1363, 893, 451, + 2025, 789, 2969, 2853, 199, 383, 347, 1701, 1254, 2615, + 1702, 2324, -1, -1, 505, 506, 507, 452, 509, 510, + 511, 512, 513, 514, -1, -1, -1, 222, 463, -1, + 373, 1693, -1, -1, -1, -1, 3003, 176, -1, -1, + -1, -1, 518, -1, 1231, 480, -1, 1234, 1235, -1, + -1, -1, -1, -1, -1, -1, 222, -1, -1, -1, + -1, -1, -1, 202, -1, 2373, -1, -1, -1, 504, + -1, -1, -1, -1, 452, -1, -1, -1, 3045, 457, + 423, -1, 425, 518, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 3100, 292, -1, 442, + -1, -1, 447, 1765, 1766, 448, 3073, 448, 451, 3045, + -1, -1, 251, -1, 3081, -1, 457, 3084, 3085, -1, + -1, -1, 261, -1, -1, -1, 292, 3060, -1, 1545, + -1, -1, 2882, 3100, 273, -1, 275, -1, -1, -1, + -1, -1, 1942, 1943, 1944, 1945, 1946, 1947, -1, -1, + 1950, 1951, 1952, 1953, 1954, 1955, 1956, 1957, 1958, 1959, + -1, 3128, 1824, -1, 172, -1, 305, 3134, -1, -1, + -1, 516, -1, -1, -1, 520, -1, -1, 1840, 1841, + -1, 1368, 1369, -1, 3151, 3152, -1, -1, 3155, 540, + 3157, -1, -1, -1, 545, -1, -1, 548, -1, -1, + -1, 2509, -1, -1, -1, 556, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 3182, -1, -1, -1, -1, + 359, -1, -1, -1, 1640, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 8, -1, -1, 2639, 3206, + -1, 2642, 15, 16, -1, 384, 19, 20, 21, -1, + -1, 1913, -1, -1, -1, -1, -1, 1919, -1, -1, + -1, -1, -1, -1, 403, -1, 405, 2575, 2669, 408, + -1, 3238, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 2684, 2685, 2686, 2687, 2688, 2689, 2690, + 2691, 2692, 2693, 3260, -1, -1, 126, 127, 37, -1, + -1, -1, 41, -1, -1, -1, -1, 315, 316, 317, + 505, 506, 507, 3280, 509, 510, 511, 512, 513, 514, + -1, -1, 3255, 3290, 3260, 3292, -1, 3294, -1, -1, + -1, 3298, -1, 3300, -1, 3302, 3280, 2137, 2138, 505, + 506, 507, 172, 509, 510, 511, 512, 513, 514, 3316, + -1, -1, -1, -1, 3321, -1, 3323, -1, 3280, -1, + -1, 1777, 101, -1, 3331, -1, -1, -1, -1, 108, + -1, 110, 2680, 112, 382, -1, -1, 3344, -1, 518, + -1, -1, 3349, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 746, 747, 748, -1, 3332, + -1, 3334, -1, -1, -1, 1592, -1, -1, 3344, -1, + -1, 419, -1, -1, -1, -1, -1, 1604, -1, 1606, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 3396, + -1, -1, -1, 1046, -1, -1, -1, 788, 789, 3406, + -1, 3374, -1, 794, 452, 796, -1, 1634, -1, -1, + -1, 3418, -1, 2253, 805, 463, -1, 3390, 809, 810, + -1, 812, -1, -1, 815, 816, 3433, -1, -1, -1, + 2778, -1, 480, -1, -1, -1, -1, 828, 829, 830, + -1, -1, 833, -1, 3451, 315, 316, 317, 55, 3433, + 841, 842, 843, 844, -1, 846, 504, 848, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 3475, 860, + 518, 3433, -1, 1929, -1, 866, -1, -1, -1, 292, + -1, -1, -1, 3490, -1, 1941, -1, 878, -1, -1, + 3280, 3475, 3499, -1, 3501, 102, -1, -1, -1, 2940, + -1, 892, 893, -1, -1, -1, -1, -1, -1, -1, + 1737, 1738, 382, 3475, 2862, 1971, 123, 3524, 151, -1, + -1, -1, 1978, 393, -1, 3501, -1, -1, -1, -1, + -1, 3538, 3539, 3540, 141, -1, 927, 928, 145, 172, + 3524, -1, -1, 3516, -1, 415, -1, -1, 939, 419, + -1, -1, 943, 944, 945, 946, -1, -1, 3565, -1, + -1, 168, 3524, 2019, 171, -1, -1, 2023, 959, 3542, + -1, -1, -1, 2029, 1801, -1, -1, 1230, -1, -1, + 187, -1, 452, -1, 1811, -1, -1, 1814, -1, -1, + -1, 2293, -1, 463, -1, -1, 2052, -1, 1046, 3606, + 991, 992, -1, 994, -1, -1, 997, 1046, -1, -1, + 480, -1, 1003, 1004, -1, -1, -1, -1, -1, 1010, + -1, 2969, -1, -1, -1, 1016, -1, 1018, -1, 0, + -1, -1, -1, -1, 504, -1, 1027, -1, -1, -1, + -1, -1, -1, 3433, 2346, -1, 1037, -1, 518, 20, + -1, -1, 23, -1, -1, 3003, -1, -1, -1, -1, + -1, -1, 2364, 1054, -1, 37, 37, -1, 1321, -1, + 42, -1, -1, 280, -1, 46, -1, -1, -1, -1, + -1, 288, 315, 316, 317, 3475, 1913, -1, -1, -1, -1, -1, 505, 506, 507, -1, 509, 510, 511, 512, - 513, 514, 1054, -1, -1, -1, -1, -1, -1, 2506, - -1, -1, 505, 506, 507, -1, 509, 510, 511, 512, - 513, 514, -1, -1, 3474, -1, -1, -1, 3373, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 1046, -1, -1, 3389, -1, 1046, 315, 316, 317, - 173, -1, -1, 1105, -1, -1, -1, -1, 181, -1, - -1, -1, -1, -1, 2677, -1, -1, 1195, -1, 100, - -1, -1, -1, 3523, -1, 2572, 1204, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 209, 505, 506, 507, - -1, 509, 510, 511, 512, 513, 514, 2710, -1, -1, - -1, -1, 225, -1, -1, -1, 1158, -1, 2506, -1, - -1, 55, 235, -1, 382, -1, 147, -1, 1046, -1, - -1, -1, 1174, 1175, -1, 393, -1, -1, -1, 1181, - -1, 162, -1, -1, -1, -1, 167, -1, -1, -1, - -1, 172, -1, -1, -1, -1, 269, 415, -1, -1, - 181, 419, 1204, 1205, 1206, 186, -1, -1, 102, -1, - -1, -1, -1, -1, 1216, 1217, -1, 290, -1, -1, - 3515, 439, -1, -1, 2572, -1, -1, 1229, 8, 123, - 2677, 11, -1, -1, 452, 15, 16, 218, -1, 19, - 20, 21, 315, -1, 1246, 463, 3541, 141, 1250, 322, - -1, 145, -1, 1255, -1, -1, 36, 238, -1, 2510, - 2511, -1, 480, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 168, 1230, -1, 171, -1, -1, - 1230, -1, -1, -1, -1, -1, 504, -1, 0, 1046, - -1, 364, -1, 187, -1, -1, -1, -1, -1, -1, - 518, -1, 1046, -1, -1, -1, 287, -1, -1, 290, - 383, -1, 1314, -1, 1316, 296, -1, -1, -1, -1, - -1, -1, 2885, 1325, -1, -1, -1, -1, -1, 2677, - 2777, 37, -1, -1, 1336, 41, -1, -1, -1, -1, - -1, -1, -1, 1345, -1, -1, -1, -1, 1350, -1, - 1352, 1353, 1230, 1355, 1356, 336, -1, 1435, 1436, -1, - -1, -1, -1, 1441, -1, -1, 1321, -1, -1, -1, - -1, 1321, -1, -1, -1, -1, -1, -1, -1, 452, - 361, -1, -1, -1, 457, -1, 280, -1, 100, -1, - -1, -1, -1, -1, 288, 101, -1, -1, -1, -1, - -1, -1, 108, -1, 110, -1, 112, -1, -1, -1, - -1, -1, -1, -1, 2861, -1, 310, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 2677, -1, -1, 2777, - -1, -1, -1, 1435, 1436, 147, -1, -1, 419, 1441, - -1, 1443, 222, 1321, -1, 339, -1, -1, -1, -1, - 162, -1, -1, -1, 1456, 167, 1458, 1459, -1, -1, - 172, 1463, 1464, -1, 1466, -1, 447, -1, -1, 181, - 1472, -1, 1474, 1230, 186, 1477, 457, -1, -1, -1, - 1482, -1, 1484, 1485, -1, 1487, 1230, -1, -1, 1491, - 3053, 1493, -1, 1495, -1, -1, 477, -1, 479, 480, - -1, -1, -1, -1, -1, -1, 218, -1, -1, -1, - 13, -1, 292, 2861, -1, -1, 19, 3080, -1, -1, - 23, 2968, -1, -1, -1, -1, 238, 30, -1, -1, - -1, -1, -1, -1, -1, 516, -1, -1, 519, 520, - 521, 44, 45, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 3002, -1, -1, -1, -1, - -1, 2812, -1, -1, 1321, -1, -1, -1, -1, -1, - -1, -1, 75, 76, -1, 287, -1, 1321, 290, -1, - -1, -1, -1, -1, 296, -1, -1, -1, -1, -1, - 1545, -1, -1, -1, -1, 1545, -1, -1, 1600, -1, - -1, -1, -1, -1, 3167, -1, 109, -1, -1, -1, - 1612, -1, -1, -1, 8, -1, -1, 11, -1, -1, - 2968, 15, 16, -1, 336, 19, 20, 21, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 3084, -1, -1, - -1, -1, 36, -1, -1, -1, -1, -1, 1726, 361, - 1652, -1, -1, 1655, 3002, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 1545, -1, -1, - -1, -1, -1, -1, 3237, -1, -1, -1, -1, -1, - 3127, 1683, -1, -1, -1, 1640, -1, -1, -1, -1, - 1640, -1, -1, -1, -1, -1, 1698, -1, 1700, -1, - 1702, -1, -1, -1, -1, -1, 2957, 419, -1, -1, - 1712, 2962, 1714, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 1726, 505, 506, 507, -1, 509, - 510, 511, 512, 513, 514, 447, 3084, -1, -1, -1, - -1, -1, -1, -1, -1, 457, -1, 0, -1, 1751, - -1, 1753, -1, -1, -1, -1, -1, -1, 3009, 3010, - -1, -1, 1640, 1765, 1766, 477, -1, 479, 480, 1771, - 1772, -1, -1, -1, -1, -1, -1, -1, -1, 3127, - 1782, 1783, 1784, 1785, -1, 1787, -1, -1, 1545, -1, - 3237, 1793, -1, 1795, -1, -1, -1, -1, -1, -1, - -1, 1545, 3365, -1, 516, 1807, 1808, 519, 520, 521, - 1812, 1813, -1, -1, -1, 1817, 1818, 1819, 1820, -1, - 1822, 1823, 1777, -1, -1, -1, -1, 1777, 222, -1, - -1, -1, -1, -1, 540, -1, -1, -1, 1840, 545, - -1, -1, 548, -1, -1, -1, 1848, 100, 1850, 1851, - 1852, 1853, 1854, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 1940, 1941, 1942, 1943, 1944, 1945, -1, 1871, - 1948, 1949, 1950, 1951, 1952, 1953, 1954, 1955, 1956, 1957, - -1, -1, -1, 1640, -1, -1, -1, -1, 1890, 3237, - -1, -1, -1, -1, 147, -1, 1640, -1, 292, 1777, - 8, -1, -1, 11, -1, -1, -1, 15, 16, 162, - -1, 19, 20, 21, 167, -1, -1, -1, -1, 172, - -1, -1, -1, -1, -1, -1, -1, -1, 181, -1, - -1, -1, -1, 186, -1, 3498, -1, -1, 1940, 1941, - 1942, 1943, 1944, 1945, -1, -1, 1948, 1949, 1950, 1951, - 1952, 1953, 1954, 1955, 1956, 1957, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 218, -1, -1, -1, -1, - -1, -1, 1927, 3224, 3225, -1, 1978, 1927, -1, -1, - -1, -1, -1, -1, 1939, 238, 3237, -1, -1, 1939, - 1992, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 2003, -1, -1, -1, -1, -1, 2009, -1, -1, - -1, -1, -1, 2015, 1969, -1, -1, -1, 2020, 1969, - 1777, 1976, -1, -1, -1, -1, 1976, 2029, 2030, -1, - -1, -1, -1, 1777, 287, -1, -1, 290, -1, -1, - -1, -1, -1, 296, -1, -1, -1, -1, -1, 1927, - -1, 3498, -1, 556, -1, -1, -1, 2135, 2136, -1, - -1, 1939, 2017, -1, -1, -1, 2021, 2017, -1, -1, - -1, 2021, 2027, -1, -1, -1, -1, 2027, -1, -1, - -1, -1, -1, 336, -1, 8, -1, -1, 11, -1, - 796, 1969, 15, 16, -1, 2050, -1, -1, 1976, 2101, - 2050, -1, -1, -1, 2106, -1, -1, -1, 361, 2111, - -1, 505, 506, 507, 222, 509, 510, 511, 512, 513, - 514, -1, -1, 46, -1, -1, -1, -1, -1, -1, - 53, -1, -1, 2135, 2136, -1, -1, -1, -1, 2017, - -1, -1, -1, 2021, -1, -1, -1, -1, -1, 2027, - 3498, -1, 2154, -1, -1, -1, -1, 80, 2160, -1, - -1, -1, -1, -1, -1, -1, 419, -1, 126, 127, - 1927, -1, 2050, 2251, -1, -1, -1, -1, -1, -1, - -1, -1, 1939, 1927, 292, 2187, 892, -1, -1, -1, - -1, -1, -1, -1, 447, 1939, -1, 2199, -1, -1, - -1, -1, 2204, -1, 457, -1, 2208, -1, -1, -1, - -1, -1, 1969, -1, 172, -1, -1, -1, -1, 1976, - -1, 927, 145, -1, 477, 1969, 479, 480, -1, -1, - -1, -1, 1976, -1, -1, -1, -1, 943, 944, 945, - 946, -1, -1, -1, 747, 748, 2248, 3498, -1, 2251, - -1, 2253, 2254, -1, 177, -1, -1, -1, -1, -1, - 2017, -1, -1, 516, 2021, -1, 519, 520, 521, -1, - 2027, 194, 2274, 2017, -1, -1, 199, 2021, -1, -1, - -1, -1, -1, 2027, -1, -1, -1, -1, 994, -1, - -1, -1, -1, 2050, -1, -1, -1, -1, -1, -1, - -1, -1, 805, -1, -1, -1, 2050, -1, -1, -1, - -1, -1, -1, -1, 237, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 2345, -1, -1, -1, -1, -1, -1, - 2352, -1, -1, -1, -1, -1, -1, 315, 316, 317, - -1, 2363, -1, 866, 2366, 2367, 2368, 2369, -1, 292, - -1, -1, -1, -1, -1, -1, -1, -1, 2380, -1, - 2382, -1, -1, 2385, -1, -1, -1, -1, -1, -1, - 2392, -1, -1, -1, -1, -1, 2398, 505, 506, 507, - -1, 509, 510, 511, 512, 513, 514, -1, -1, -1, - -1, -1, -1, -1, -1, 2370, -1, -1, 2420, 2421, - 2370, 2423, -1, -1, 382, 8, -1, -1, 11, -1, - -1, -1, 15, 16, -1, 393, -1, -1, -1, -1, - -1, -1, -1, -1, 997, -1, -1, -1, -1, -1, - 2452, -1, -1, -1, -1, -1, -1, 415, -1, -1, - -1, 419, -1, 46, -1, -1, -1, -1, 2470, -1, - 53, 394, -1, -1, -1, -1, 2478, 2479, 2480, -1, - -1, -1, -1, -1, -1, -1, 2488, -1, 2490, -1, - 2492, -1, 2370, -1, 452, -1, 2498, 80, 2576, 2577, - -1, -1, -1, -1, -1, 463, -1, 1010, -1, -1, - 1216, -1, -1, 1016, -1, 1018, 2518, -1, -1, -1, - -1, -1, 480, 1229, 1027, -1, -1, -1, -1, -1, - 2532, -1, -1, -1, 1037, -1, -1, -1, -1, -1, - -1, 2543, -1, -1, 1250, 2547, 504, -1, -1, -1, - -1, 2506, -1, -1, -1, -1, 2506, -1, -1, -1, - 518, -1, 145, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 2576, 2577, -1, -1, -1, 502, - -1, -1, -1, -1, -1, -1, 509, 510, 511, 512, - 513, 514, -1, -1, 177, -1, -1, -1, -1, -1, - -1, -1, 1105, 2605, -1, -1, -1, -1, -1, 2611, - 1316, 194, -1, 2370, -1, -1, 199, 2572, -1, 1325, - -1, -1, 2572, -1, -1, 2627, 2370, -1, 2506, 2631, - -1, 2633, -1, 2635, 2636, -1, -1, 2639, -1, -1, - -1, 2643, 2644, 2645, -1, 2647, -1, -1, -1, -1, - -1, 1204, -1, -1, 237, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 2666, -1, 2668, -1, -1, -1, - -1, 1174, 1175, -1, -1, -1, -1, -1, -1, 2681, - 2682, 2683, 2684, 2685, 2686, 2687, 2688, 2689, 2690, -1, - -1, -1, -1, -1, 2572, -1, 2774, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 292, - -1, -1, 2714, -1, -1, -1, -1, -1, -1, 2721, - -1, 2799, 2677, -1, -1, -1, -1, 2677, -1, -1, - -1, 2733, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 2506, - -1, 2753, -1, -1, -1, -1, -1, -1, -1, -1, - 1466, 2763, 2506, -1, -1, -1, -1, -1, -1, -1, - -1, 2849, 2774, -1, -1, -1, -1, -1, 2780, -1, - -1, -1, -1, -1, -1, 2787, 2788, 2789, 2790, 40, - -1, -1, -1, -1, -1, -1, -1, 2799, -1, 2677, - 2802, -1, -1, -1, 2806, 2807, -1, -1, -1, 60, - -1, 394, -1, 2815, -1, 2572, -1, -1, -1, -1, - -1, -1, 2777, -1, -1, -1, -1, 2777, 2572, -1, - -1, -1, -1, -1, -1, -1, 2838, -1, -1, -1, - -1, -1, -1, 2845, 2846, -1, -1, -1, 2850, 1352, - 1353, -1, 1355, -1, -1, 106, 107, -1, -1, -1, - -1, -1, 2940, -1, -1, -1, 117, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 2879, -1, 2881, - -1, -1, 1435, 1436, -1, -1, 2888, -1, 1441, -1, - -1, -1, -1, 2895, -1, -1, -1, 2899, -1, 2777, - -1, -1, -1, 2905, -1, -1, 2861, -1, -1, -1, - -1, 2861, -1, -1, -1, -1, -1, 2919, -1, 502, - 2677, -1, -1, 2925, -1, 176, 509, 510, 511, 512, - 513, 514, -1, 2677, -1, -1, 2938, 2939, 2940, -1, - -1, -1, -1, -1, 2946, -1, -1, -1, -1, -1, - -1, 202, -1, -1, -1, 1458, -1, -1, -1, -1, - -1, 2963, -1, -1, -1, -1, -1, -1, -1, 1472, - -1, 1474, -1, -1, 1477, -1, -1, -1, -1, 1482, - -1, -1, 1485, 2861, 1487, -1, -1, -1, 1491, -1, - 1493, -1, 1495, -1, 1700, -1, 1702, -1, -1, -1, - 251, -1, -1, -1, -1, 3083, 1712, -1, -1, -1, - 261, -1, -1, 2968, -1, -1, -1, -1, 2968, -1, - 2777, -1, 273, -1, 275, -1, -1, -1, -1, -1, - -1, -1, -1, 2777, -1, -1, -1, -1, -1, 3041, - -1, -1, -1, 3045, -1, 1751, -1, 3002, -1, -1, - -1, -1, 3002, -1, 305, -1, 3058, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 3076, -1, -1, -1, -1, -1, - -1, 3083, -1, -1, -1, -1, -1, -1, -1, -1, - 2968, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 2861, -1, -1, 3109, 359, 1612, - -1, -1, -1, 3115, -1, -1, -1, 2861, -1, -1, - 3122, 3, -1, 5, 3002, -1, -1, -1, 1681, 3084, - -1, -1, -1, 384, 3084, -1, -1, 3139, -1, -1, - -1, -1, -1, -1, 1850, 1851, 1852, 1853, 1854, -1, - -1, -1, 403, -1, 405, -1, -1, 408, -1, -1, - -1, 3163, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 3127, 1726, -1, -1, -1, 3127, -1, -1, - -1, -1, -1, 3185, -1, -1, 68, 69, 3190, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 3084, -1, -1, -1, - -1, 2968, -1, -1, 3216, -1, -1, -1, -1, -1, - -1, 3299, -1, -1, 2968, -1, -1, 109, 110, -1, - -1, 113, 114, -1, -1, -1, 3238, 3239, -1, -1, - -1, -1, -1, -1, -1, 3002, -1, -1, -1, 3127, - 1753, -1, -1, 3255, -1, 3257, -1, -1, 3002, -1, - 3262, -1, -1, -1, -1, -1, -1, 518, -1, 1772, - -1, -1, -1, -1, 3276, -1, -1, 3279, -1, 1782, - -1, 1784, 3237, -1, 1787, -1, 1992, 3237, -1, -1, - 1793, -1, 1795, -1, -1, -1, -1, 3299, -1, 3301, - -1, 3303, 3304, -1, 3306, 1808, -1, 189, 190, 3311, - 1813, -1, -1, -1, 1817, 1818, 1819, 1820, -1, 1822, - 1823, -1, -1, -1, -1, -1, -1, 3084, 3330, -1, - -1, -1, 3334, -1, -1, -1, -1, -1, -1, 3341, - 3084, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 3237, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 3371, - 3127, 253, 254, 255, 256, 257, 258, 259, 260, -1, - -1, 263, 264, 3127, -1, -1, -1, 1940, 1941, 1942, - 1943, 1944, 1945, -1, -1, 1948, 1949, 1950, 1951, 1952, - 1953, 1954, 1955, 1956, 1957, -1, -1, 3409, -1, -1, - -1, -1, -1, -1, -1, 3417, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 3432, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 337, 338, 3459, -1, -1, - -1, -1, -1, 841, 842, -1, -1, -1, -1, 3471, - 3472, -1, 3474, 3475, -1, 1978, 0, -1, -1, -1, - 3237, 3483, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 3494, 3237, -1, -1, 378, 379, 22, -1, - 2003, -1, -1, -1, 24, -1, 2009, -1, 32, -1, - 34, 35, 2015, -1, 3516, -1, -1, 2020, -1, -1, - -1, 3523, -1, 47, -1, -1, -1, -1, 52, -1, - -1, -1, -1, -1, 912, -1, -1, 61, 916, 917, - -1, -1, -1, 3498, -1, -1, -1, -1, 3498, -1, - -1, 75, -1, -1, -1, -1, 8, -1, 3560, 11, - 84, 81, 86, 15, 16, 17, 18, 19, 20, 21, - -1, -1, -1, 3575, 98, -1, 100, 97, -1, -1, - -1, -1, 2135, 2136, 36, -1, -1, 111, -1, -1, - -1, 969, 474, 475, 46, -1, -1, -1, 2101, -1, - -1, 53, 126, 127, 128, -1, -1, -1, 2111, 987, - -1, -1, -1, 137, -1, 993, 498, 499, 996, 143, - 3498, 999, 1000, 1001, 1002, -1, 146, 151, 80, 153, - 154, -1, -1, -1, -1, -1, 156, -1, -1, -1, - -1, -1, -1, -1, 168, -1, 2352, -1, 172, 169, - -1, -1, -1, -1, 174, -1, -1, -1, -1, -1, - -1, 2367, 2368, 2369, -1, -1, 1044, 1045, -1, -1, - -1, -1, -1, -1, 198, -1, 2382, -1, -1, 2385, - -1, -1, -1, 203, 2187, -1, 2392, -1, 1066, -1, - 214, -1, -1, -1, -1, -1, 2199, -1, 2251, -1, - -1, 2204, -1, -1, -1, -1, -1, 1085, -1, -1, - -1, -1, -1, -1, -1, -1, 240, -1, 1096, 1097, - 1098, -1, 1100, 1101, -1, 177, 246, -1, -1, -1, - 250, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 3498, 194, -1, -1, 2248, -1, 199, -1, -1, - -1, 2254, -1, -1, 3498, -1, -1, -1, 1136, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 222, 223, 2478, 2479, 2480, -1, 1154, 1155, -1, -1, - -1, -1, -1, -1, -1, 237, -1, -1, -1, -1, - -1, 315, 316, 317, 314, -1, -1, -1, -1, 323, - 320, -1, 326, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 1190, -1, -1, 335, 1194, 1195, -1, -1, - -1, -1, -1, 275, -1, -1, 278, 1205, 1206, -1, - -1, -1, -1, 357, -1, -1, -1, -1, -1, -1, - 292, -1, 366, 295, -1, -1, -1, -1, -1, -1, - 370, -1, -1, 373, -1, -1, -1, -1, 382, -1, - -1, -1, -1, -1, 384, 389, 26, 387, -1, 393, - -1, -1, 32, -1, -1, -1, -1, 2380, -1, 403, - 40, -1, -1, -1, -1, 405, -1, 1265, -1, -1, - -1, 415, -1, -1, -1, 419, 1274, -1, -1, 419, - 60, -1, -1, -1, -1, 425, 426, -1, -1, -1, - -1, -1, -1, -1, -1, 439, 436, -1, -1, -1, - 1298, 2627, 442, -1, -1, -1, -1, -1, 452, -1, - -1, 455, -1, -1, 458, -1, -1, -1, -1, 463, - -1, -1, 394, -1, -1, -1, 106, -1, -1, -1, - 470, -1, -1, -1, -1, -1, 480, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 137, -1, -1, - 504, -1, -1, -1, -1, 2488, -1, -1, -1, 2492, - -1, -1, -1, -1, 518, 2498, -1, 521, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 1385, -1, -1, - -1, -1, -1, -1, -1, 2721, -1, -1, -1, -1, - -1, -1, -1, 2576, 2577, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 2543, -1, 202, -1, 2547, -1, -1, -1, -1, -1, - 502, -1, -1, 505, 506, 507, -1, 509, 510, 511, - 512, 513, 514, -1, -1, -1, -1, -1, -1, -1, - 1448, 523, 1450, 1451, -1, -1, -1, -1, -1, -1, - -1, 2787, 2788, 2789, 2790, 1463, 1464, -1, -1, -1, - -1, 251, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 261, -1, -1, -1, -1, 1484, -1, -1, -1, - -1, -1, -1, 273, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 2631, -1, - -1, -1, 2635, 2636, 294, -1, 2639, -1, -1, -1, - -1, -1, -1, -1, -1, 305, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 2666, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 2681, 2682, - 2683, 2684, 2685, 2686, 2687, 2688, 2689, 2690, -1, -1, - -1, -1, -1, 353, -1, -1, -1, 357, -1, 359, - -1, -1, -1, -1, -1, -1, -1, -1, 1586, -1, - -1, -1, -1, -1, -1, -1, 1594, -1, -1, -1, - -1, 2774, -1, -1, 384, -1, -1, -1, -1, 389, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 2946, -1, -1, 403, -1, -1, 2799, -1, -1, -1, - 1628, -1, -1, -1, -1, -1, -1, 1635, -1, -1, - -1, -1, -1, 1641, 1642, 1643, 1644, 1645, 1646, 1647, - 1648, -1, -1, -1, -1, 1653, 1654, 2780, -1, -1, - 1658, -1, -1, -1, 1662, -1, -1, 1665, 1666, 1667, - 1668, 1669, 1670, 1671, 1672, 1673, -1, -1, 1676, -1, - 460, -1, -1, 2806, -1, 1683, -1, 1685, -1, -1, + 513, 514, -1, 310, 75, 76, 77, 2409, -1, -1, + -1, -1, -1, -1, 1105, -1, -1, 2419, -1, 2421, + -1, -1, -1, 2425, -1, 2427, -1, -1, -1, 101, + 101, -1, 339, -1, 3524, -1, -1, 3085, -1, 2579, + 2580, -1, -1, -1, -1, -1, -1, -1, -1, 382, -1, 8, -1, -1, 11, -1, -1, -1, 15, 16, - -1, -1, -1, -1, -1, 1703, -1, -1, -1, 8, - -1, -1, 11, -1, -1, 2838, 15, 16, 17, 18, - 19, 20, 21, 2846, -1, -1, -1, -1, -1, 46, - -1, -1, -1, -1, -1, -1, 53, 36, -1, 1737, - 1738, -1, -1, -1, -1, -1, -1, 46, -1, -1, - -1, -1, -1, -1, 53, -1, -1, -1, 2881, -1, - -1, -1, -1, 80, -1, -1, -1, 2940, -1, -1, - -1, 3, -1, -1, -1, -1, 8, -1, -1, 11, - -1, 80, -1, 15, 16, 17, 18, 19, 20, 21, - -1, 8, -1, -1, 11, -1, -1, -1, 15, 16, - -1, -1, -1, -1, 36, -1, -1, -1, 40, -1, - -1, -1, -1, -1, 46, -1, 2939, -1, -1, -1, - -1, 53, -1, -1, -1, -1, -1, -1, 145, 46, - 1828, -1, -1, -1, -1, 1833, 53, -1, 1836, 1837, - -1, -1, -1, 8, -1, -1, 11, -1, 80, -1, - 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, - 177, -1, -1, 80, -1, -1, -1, -1, -1, -1, - -1, 36, -1, -1, -1, 40, -1, 194, 177, 1877, - -1, 46, 199, -1, -1, -1, -1, -1, 53, -1, - -1, -1, -1, -1, -1, 194, -1, -1, -1, -1, - 199, -1, -1, -1, 1902, 1903, -1, -1, -1, -1, - 3083, -1, -1, -1, 8, 80, -1, 11, -1, -1, - 237, 15, 16, 222, 223, 19, 20, 21, 145, 3255, - -1, -1, -1, 1931, 1932, -1, 1934, -1, 237, -1, - -1, -1, 36, -1, -1, 177, -1, -1, -1, -1, - 3276, -1, 46, -1, -1, -1, -1, -1, -1, 53, - 177, -1, 194, -1, -1, 1963, 1964, 199, -1, 1967, - -1, -1, -1, -1, -1, 292, 275, 194, -1, 278, - -1, -1, 199, -1, -1, -1, 80, -1, -1, -1, - 222, 223, 3115, 292, -1, -1, 295, -1, -1, 3122, - 1998, -1, -1, -1, -1, 237, -1, 2005, -1, -1, - -1, -1, 177, -1, 8, 3341, -1, 11, -1, -1, - 237, 15, 16, -1, -1, 2023, -1, 2025, -1, 194, - -1, -1, -1, -1, 199, -1, -1, -1, -1, -1, - -1, -1, -1, 275, -1, 3371, 278, 997, -1, -1, - -1, -1, 46, -1, -1, -1, -1, 222, 223, 53, - 292, -1, 3185, 295, -1, 2063, -1, 3190, -1, -1, - -1, -1, 237, -1, -1, 292, -1, 394, -1, -1, - -1, -1, -1, 177, -1, -1, 80, -1, -1, -1, - -1, -1, -1, 3216, -1, 394, -1, -1, -1, -1, - 194, -1, 2100, -1, -1, 199, 2104, -1, -1, -1, - 275, 2109, 2110, 278, -1, 3238, 3239, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 3299, 292, 222, 223, - 295, -1, -1, -1, -1, -1, -1, -1, -1, 3262, - -1, -1, -1, 237, -1, -1, -1, -1, -1, -1, - -1, 145, -1, -1, -1, -1, -1, -1, 2156, -1, - -1, 2159, 394, 2161, -1, -1, -1, -1, -1, -1, - -1, 1121, -1, -1, -1, -1, -1, 394, -1, 2177, - 3303, 275, -1, 177, 278, 502, -1, -1, 3311, -1, - -1, -1, 509, 510, 511, 512, 513, 514, 292, -1, - 194, 295, -1, 502, -1, 199, 505, 506, 507, -1, - 509, 510, 511, 512, 513, 514, -1, -1, -1, 2217, - 1170, -1, -1, 522, -1, -1, -1, -1, -1, 394, - -1, -1, -1, -1, -1, -1, 2234, 2235, -1, -1, - -1, -1, -1, 237, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 1204, 2253, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 2266, -1, - 502, -1, -1, 505, 506, 507, -1, 509, 510, 511, - 512, 513, 514, -1, -1, 502, -1, -1, -1, -1, - -1, -1, 509, 510, 511, 512, 513, 514, 292, -1, - 394, -1, -1, -1, -1, -1, -1, -1, -1, 1259, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 2323, -1, -1, -1, -1, - -1, 2329, -1, -1, -1, -1, -1, 502, -1, -1, - 505, 506, 507, -1, 509, 510, 511, 512, 513, 514, - -1, -1, 1302, -1, 519, -1, -1, -1, -1, 1309, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 3494, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 540, 19, 20, 21, -1, 545, 1158, -1, 548, + -1, -1, -1, -1, -1, -1, 3217, -1, -1, -1, + 3128, -1, 1230, 1174, 1175, -1, 419, -1, -1, 46, + 1181, 1230, -1, -1, -1, -1, 53, -1, 3239, 3240, + -1, 173, -1, -1, -1, -1, -1, -1, -1, 2036, + -1, -1, -1, 1204, 1205, 1206, -1, -1, -1, 452, + -1, 0, 3263, 80, -1, 1216, 1217, -1, -1, -1, + 463, 37, -1, -1, -1, -1, 42, 209, 1229, -1, + -1, -1, -1, -1, -1, -1, -1, 480, -1, -1, + -1, -1, -1, 225, 1046, 1246, -1, -1, -1, 1250, + 26, -1, -1, 235, 1255, -1, 32, -1, -1, -1, + -1, 504, -1, 1321, 40, -1, -1, -1, -1, -1, + -1, -1, 1321, -1, -1, 518, -1, -1, -1, -1, + 3238, -1, 1545, -1, 60, 101, -1, 269, -1, -1, + -1, -1, -1, -1, -1, 151, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 2373, -1, -1, + 177, 100, -1, 1314, -1, 1316, 172, -1, -1, -1, + -1, -1, -1, -1, 1325, 2775, -1, 194, -1, -1, + 106, 8, 199, 315, 11, 1336, -1, -1, 15, 16, + 322, -1, -1, -1, 1345, -1, -1, -1, -1, 1350, + 2800, 1352, 1353, -1, 1355, 1356, 2193, 173, 147, -1, + -1, 137, -1, -1, -1, -1, -1, -1, 2680, 46, + 237, -1, -1, 162, -1, -1, 53, 1640, 167, -1, + -1, -1, 364, 172, -1, -1, -1, -1, -1, 2226, + 2227, -1, 181, 209, -1, -1, -1, 186, -1, 2711, + 2850, 383, -1, 80, -1, -1, -1, 796, -1, 225, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 235, + -1, -1, -1, -1, -1, 292, 202, -1, 1230, 218, + -1, -1, -1, -1, 1435, 1436, -1, -1, -1, -1, + 1441, -1, 1443, 2509, 3495, -1, -1, -1, -1, 238, + -1, -1, -1, 269, -1, 1456, -1, 1458, 1459, 315, + 316, 317, 1463, 1464, -1, 1466, -1, -1, 145, -1, + 452, 1472, -1, 1474, 290, 251, 1477, -1, -1, -1, + -1, 1482, -1, 1484, 1485, 261, 1487, 1545, -1, -1, + 1491, 2941, 1493, -1, 1495, -1, 1545, 273, 287, 315, + 177, 290, -1, 892, -1, -1, 322, 296, -1, 2575, + -1, -1, -1, -1, 1777, -1, -1, 194, 294, 1321, + -1, -1, 199, -1, -1, -1, 382, 394, -1, 305, + -1, -1, -1, -1, -1, -1, -1, -1, 927, -1, + -1, 3499, -1, -1, -1, -1, -1, 336, 364, -1, + -1, -1, -1, -1, 943, 944, 945, 946, 539, -1, + 237, -1, -1, 419, -1, -1, -1, 383, -1, -1, + -1, -1, 361, -1, 2886, -1, -1, 353, -1, -1, + -1, 357, 1640, 359, -1, -1, -1, 13, -1, -1, + -1, 1640, -1, 19, -1, -1, 452, 23, -1, 1600, + -1, -1, -1, -1, 30, 994, -1, 463, 384, -1, + -1, 1612, -1, 389, 2680, 292, -1, -1, 44, 45, + -1, -1, -1, -1, 480, -1, -1, 403, -1, -1, + 419, -1, -1, -1, 3084, 502, 452, -1, 505, 506, + 507, 457, 509, 510, 511, 512, 513, 514, 504, 75, + 76, 1652, -1, -1, 1655, -1, -1, -1, 447, -1, + -1, -1, 518, -1, -1, -1, 1929, -1, 457, -1, + -1, -1, -1, -1, -1, -1, 2513, 2514, 1941, -1, + -1, -1, 1683, 109, 460, -1, -1, -1, 477, -1, + 479, 480, -1, -1, -1, -1, -1, 1698, -1, 1700, + -1, 1702, -1, -1, -1, -1, -1, -1, 1971, -1, + -1, 1712, 2778, 1714, -1, 1978, -1, 394, -1, 1777, + -1, -1, -1, -1, -1, 1726, -1, 516, 1777, -1, + 519, 520, 521, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 3054, 1545, -1, -1, -1, -1, 40, -1, + 1751, -1, 1753, -1, -1, -1, 2019, -1, -1, -1, + 2023, -1, -1, -1, 1765, 1766, 2029, -1, 60, 3081, + 1771, 1772, 753, 754, -1, -1, -1, -1, -1, -1, + -1, 1782, 1783, 1784, 1785, -1, 1787, -1, -1, 2052, + -1, -1, 1793, -1, 1795, -1, 2862, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 1807, 1808, -1, -1, + -1, 1812, 1813, 794, 106, -1, 1817, 1818, 1819, 1820, + -1, 1822, 1823, -1, 805, 502, -1, 1216, -1, -1, + -1, 812, 509, 510, 511, 512, 513, 514, 1640, -1, + 1229, 1842, -1, 2680, -1, -1, -1, -1, -1, 1850, + 3300, 1852, 1853, 1854, 1855, 1856, 3168, -1, -1, -1, + -1, 1250, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 1929, 1873, -1, -1, -1, 857, -1, -1, -1, + 1929, -1, -1, 1941, -1, -1, -1, -1, -1, -1, + -1, 1892, 1941, -1, 875, -1, -1, -1, -1, -1, + -1, -1, -1, 2969, -1, -1, -1, -1, -1, -1, + 202, -1, -1, 1971, -1, -1, -1, -1, -1, -1, + 1978, -1, 1971, -1, -1, -1, 3238, 1316, -1, 1978, + -1, -1, -1, -1, -1, -1, 1325, 3003, -1, -1, + -1, 1942, 1943, 1944, 1945, 1946, 1947, -1, -1, 1950, + 1951, 1952, 1953, 1954, 1955, 1956, 1957, 1958, 1959, 251, + -1, 2019, -1, -1, -1, 2023, -1, -1, -1, 261, + 2019, 2029, -1, -1, 2023, 1777, 2813, 98, -1, 1980, + 2029, 273, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 1994, 2052, -1, -1, -1, -1, -1, + -1, -1, 983, 2052, 2005, 126, 127, -1, -1, -1, + 2011, -1, -1, 305, -1, -1, 2017, -1, -1, 3085, + -1, 2022, -1, -1, -1, -1, -1, -1, -1, -1, + 2031, 2032, -1, -1, -1, 1016, -1, 1018, -1, -1, + -1, -1, -1, -1, -1, -1, 1027, -1, -1, -1, + -1, 172, -1, 8, 3366, -1, 11, -1, -1, 172, + 15, 16, 3128, -1, -1, -1, -1, 359, -1, -1, + -1, 8, -1, -1, 11, -1, -1, 1466, 15, 16, + -1, 1062, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 46, 384, 1074, -1, -1, -1, -1, 53, -1, + -1, -1, 2103, -1, -1, -1, -1, 2108, -1, 46, + 2373, 403, 2113, -1, -1, -1, 53, -1, -1, -1, + 1101, 2958, -1, 0, -1, 80, 2963, 1929, -1, -1, + 556, -1, -1, -1, -1, -1, 2137, 2138, -1, 1941, + -1, -1, -1, 80, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 2156, -1, -1, -1, -1, + -1, 2162, -1, -1, -1, -1, -1, -1, -1, 1971, + -1, -1, 3238, 3010, 3011, -1, 1978, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 3499, 2189, -1, + 145, 304, -1, -1, 315, 316, 317, -1, -1, -1, + 2201, -1, 315, 316, 317, 2206, -1, 1188, 1189, 2210, + 1191, -1, -1, -1, -1, -1, -1, 2019, -1, -1, + -1, 2023, 177, 100, -1, -1, -1, 2029, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 194, + 177, -1, -1, -1, 199, -1, 2509, -1, -1, 2250, + 2052, -1, 2253, -1, 2255, 2256, -1, 194, -1, -1, + -1, 382, 199, -1, -1, -1, -1, -1, -1, 382, + 147, -1, 393, -1, -1, 2276, -1, -1, -1, -1, + -1, -1, 237, -1, -1, 162, -1, -1, -1, -1, + 167, -1, -1, -1, 415, 172, -1, -1, 419, -1, + 237, -1, -1, -1, 181, -1, 419, -1, -1, 186, + -1, 1700, 2575, 1702, -1, 2373, -1, -1, 439, -1, + -1, 747, 748, 1712, 2373, -1, -1, -1, -1, -1, + -1, 452, -1, -1, -1, -1, -1, 292, -1, 452, + -1, 218, 463, -1, -1, -1, -1, 2348, -1, -1, + 463, -1, -1, -1, 2355, 292, -1, -1, -1, 480, + -1, 238, 1751, -1, -1, 2366, -1, 480, 2369, 2370, + 2371, 2372, -1, -1, -1, -1, -1, -1, -1, 805, + -1, 1362, 2383, 504, 2385, -1, -1, 2388, 3225, 3226, + -1, 504, -1, -1, 2395, -1, -1, 518, -1, -1, + 2401, 3238, -1, -1, -1, 518, -1, -1, -1, -1, + 287, -1, -1, 290, -1, -1, -1, 2680, -1, 296, + -1, -1, 2423, 2424, -1, 2426, -1, -1, -1, -1, + -1, -1, -1, 3499, -1, -1, -1, -1, -1, 394, + 866, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 2509, -1, -1, 2455, -1, -1, 394, -1, 336, + 2509, -1, -1, 1852, 1853, 1854, 1855, 1856, -1, -1, + -1, -1, 2473, -1, -1, -1, -1, -1, -1, -1, + 2481, 2482, 2483, -1, 361, -1, -1, -1, -1, -1, + 2491, 1472, 2493, 1474, 2495, -1, 1477, -1, -1, -1, + 2501, 1482, -1, -1, 1485, -1, 1487, -1, -1, -1, + 1491, -1, -1, -1, -1, 2778, 8, 2575, -1, 11, + 2521, -1, -1, 15, 16, -1, 2575, 19, 20, 21, + -1, -1, -1, -1, 2535, -1, -1, -1, -1, -1, + -1, -1, 419, -1, 36, 2546, -1, 502, -1, 2550, + -1, -1, -1, -1, 509, 510, 511, 512, 513, 514, + -1, -1, -1, -1, -1, 502, -1, -1, -1, -1, + 447, 2373, 509, 510, 511, 512, 513, 514, 2579, 2580, + 457, -1, -1, -1, 1010, -1, -1, -1, -1, -1, + 1016, -1, 1018, 1574, -1, -1, -1, -1, -1, 2862, + 477, 1027, 479, 480, -1, 1994, -1, 2608, -1, -1, + -1, 1037, -1, 2614, -1, -1, -1, -1, -1, -1, + -1, -1, 2680, -1, -1, -1, -1, -1, -1, 2630, + -1, 2680, -1, 2634, -1, 2636, -1, 2638, 2639, 516, + -1, 2642, 519, 520, 521, 2646, 2647, 2648, 8, 2650, + -1, 11, -1, -1, -1, 15, 16, -1, -1, 19, + 20, 21, 3499, -1, -1, -1, -1, -1, 2669, -1, + 2671, -1, -1, -1, 1655, -1, 36, -1, -1, 1105, + -1, -1, -1, 2684, 2685, 2686, 2687, 2688, 2689, 2690, + 2691, 2692, 2693, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 2969, 2509, -1, -1, + -1, -1, -1, -1, 2715, -1, -1, -1, -1, -1, + 2778, 2722, -1, -1, -1, -1, -1, -1, -1, 2778, + 222, -1, -1, 2734, -1, -1, -1, -1, -1, -1, + 3003, -1, 1723, -1, -1, -1, -1, 8, 1174, 1175, + 11, -1, -1, 2754, 15, 16, -1, -1, 19, 20, + 21, -1, -1, 2764, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 2575, 2775, 36, -1, -1, -1, -1, + 2781, -1, -1, -1, -1, -1, -1, 2788, 2789, 2790, + 2791, -1, -1, -1, -1, -1, -1, -1, -1, 2800, + 292, -1, 2803, -1, 2862, -1, 2807, 2808, -1, -1, + -1, -1, -1, 2862, -1, 2816, -1, -1, 8, -1, + -1, 11, 3085, -1, -1, 15, 16, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 2839, -1, + -1, -1, -1, -1, -1, 2846, 2847, -1, -1, -1, + 2851, -1, -1, -1, -1, -1, 46, -1, -1, -1, + -1, -1, 222, 53, -1, 3128, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 2680, 2880, + -1, 2882, 1863, -1, -1, -1, -1, -1, 2889, -1, + 80, -1, -1, -1, 1875, 2896, -1, -1, -1, 2900, + -1, -1, -1, -1, -1, 2906, -1, -1, -1, -1, + -1, 2969, -1, -1, -1, -1, -1, -1, -1, 2920, + 2969, -1, -1, -1, -1, 2926, 1352, 1353, -1, 1355, + -1, -1, 292, -1, -1, -1, -1, -1, 2939, 2940, + 2941, -1, -1, -1, -1, 3003, 2947, -1, -1, -1, + -1, -1, -1, -1, 3003, 145, -1, -1, -1, -1, + -1, 222, -1, 2964, -1, -1, 2355, -1, -1, -1, + -1, -1, -1, -1, -1, 3238, 2778, -1, -1, -1, + -1, 2370, 2371, 2372, -1, -1, -1, 177, -1, -1, + -1, -1, -1, -1, -1, -1, 2385, -1, -1, 2388, + -1, -1, -1, -1, 194, -1, 2395, -1, -1, 199, + -1, -1, -1, 505, 506, 507, -1, 509, 510, 511, + 512, 513, 514, -1, 2005, -1, -1, 3085, -1, -1, + 2011, 292, 1458, -1, -1, -1, 3085, -1, -1, -1, + -1, 3042, -1, -1, -1, 3046, 1472, 237, 1474, -1, + -1, 1477, -1, -1, -1, -1, 1482, -1, 3059, 1485, + 2862, 1487, -1, -1, -1, 1491, -1, 1493, -1, 1495, + 3128, -1, -1, -1, -1, -1, 3077, -1, -1, 3128, + -1, -1, -1, 3084, -1, -1, -1, -1, -1, -1, + -1, -1, 2481, 2482, 2483, -1, -1, -1, -1, -1, + -1, -1, 292, -1, -1, -1, -1, -1, -1, 3110, + -1, -1, -1, -1, -1, 3116, -1, -1, -1, -1, + -1, -1, 3123, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 3140, + -1, -1, -1, -1, -1, 505, 506, 507, -1, 509, + 510, 511, 512, 513, 514, -1, -1, -1, -1, -1, + -1, 2142, -1, 3164, -1, -1, -1, 2969, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 2390, -1, 8, -1, -1, 11, -1, -1, - 394, 15, 16, 17, 18, 19, 20, 21, 502, 1359, - -1, 505, 506, 507, -1, 509, 510, 511, 512, 513, - 514, -1, 36, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 46, 1383, -1, -1, -1, -1, -1, 53, + 3238, 2162, -1, -1, -1, 3186, 1612, -1, -1, 3238, + 3191, -1, -1, -1, -1, -1, -1, 2178, -1, -1, + -1, 3003, -1, -1, 394, -1, -1, -1, 2189, -1, + -1, 8, -1, -1, 11, -1, 3217, -1, 15, 16, + -1, -1, 19, 20, 21, 2206, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 3499, -1, 3239, 3240, + -1, 2630, -1, -1, 505, 506, 507, -1, 509, 510, + 511, 512, 513, 514, -1, 3256, -1, 3258, -1, -1, + -1, -1, 3263, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 3277, -1, -1, 3280, + -1, -1, -1, 3085, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 3300, + -1, 3302, -1, 3304, 3305, -1, 3307, -1, -1, -1, + -1, 3312, 502, -1, -1, -1, -1, -1, -1, 509, + 510, 511, 512, 513, 514, -1, 3128, 1753, -1, -1, + 3331, -1, -1, 2722, 3335, -1, -1, -1, -1, -1, + 8, 3342, -1, 11, -1, -1, 1772, 15, 16, -1, + -1, -1, -1, -1, -1, -1, 1782, -1, 1784, -1, + -1, 1787, -1, -1, -1, -1, -1, 1793, -1, 1795, + -1, 3372, -1, -1, -1, -1, -1, -1, 46, -1, + -1, -1, 1808, 2364, -1, 53, -1, 1813, -1, -1, + -1, 1817, 1818, 1819, 1820, -1, 1822, 1823, -1, 2788, + 2789, 2790, 2791, -1, -1, -1, -1, -1, -1, 3410, + -1, -1, 80, -1, -1, -1, -1, 3418, -1, -1, + -1, -1, -1, -1, -1, 222, -1, -1, -1, -1, + -1, -1, 3433, -1, -1, -1, 3238, -1, -1, -1, + -1, 3499, -1, -1, 0, -1, -1, -1, -1, -1, + 3499, -1, -1, -1, -1, -1, -1, -1, -1, 3460, + -1, -1, -1, -1, -1, -1, 22, -1, -1, -1, + -1, 3472, 3473, -1, 3475, 3476, 32, 145, 34, 35, + -1, -1, -1, 3484, -1, -1, 841, 842, -1, -1, + -1, 47, -1, -1, 3495, 292, 52, -1, -1, -1, + -1, -1, -1, -1, -1, 61, -1, -1, -1, 177, + -1, -1, -1, -1, -1, -1, 3517, -1, -1, 75, + -1, -1, -1, 3524, -1, -1, 194, -1, 84, -1, + 86, 199, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 98, -1, 100, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 1980, 111, -1, 912, 2947, -1, + 3561, 916, 917, -1, -1, -1, 2547, -1, -1, 237, + 126, 127, 128, -1, -1, 3576, -1, -1, -1, 2005, + -1, 137, -1, -1, -1, 2011, -1, 143, -1, -1, + -1, 2017, -1, -1, -1, 151, 2022, 153, 154, -1, + -1, -1, -1, -1, 2585, -1, -1, -1, -1, -1, + -1, -1, 168, -1, 969, -1, 172, -1, -1, -1, + -1, -1, -1, 2604, 292, -1, -1, -1, -1, 2610, + -1, -1, 987, -1, -1, -1, -1, -1, 993, -1, + -1, 996, 198, -1, 999, 1000, 1001, 1002, -1, -1, + -1, -1, -1, -1, -1, 2636, -1, -1, 214, -1, -1, -1, 8, -1, -1, 11, -1, -1, -1, 15, - 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, - -1, 8, -1, -1, 11, -1, 80, -1, 15, 16, - 36, -1, 19, 20, 21, -1, -1, -1, -1, -1, - 46, 1431, -1, 1433, -1, 1435, 1436, 53, 1438, 36, - -1, 1441, -1, -1, 1444, -1, -1, 1447, -1, 46, - -1, -1, 1452, -1, -1, 1455, 53, -1, 502, -1, - -1, -1, -1, -1, 80, 509, 510, 511, 512, 513, - 514, -1, -1, -1, -1, 2523, -1, -1, -1, -1, - -1, 2529, 2530, 80, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 2544, -1, 1498, -1, + 16, -1, -1, 19, 20, 21, -1, 2103, -1, -1, + -1, -1, -1, -1, 240, -1, -1, 2113, -1, 1044, + 1045, -1, -1, -1, -1, -1, -1, 3499, -1, -1, + 46, -1, -1, -1, -1, -1, -1, 53, 505, 506, + 507, 1066, 509, 510, 511, 512, 513, 514, -1, -1, + 8, -1, -1, 11, -1, -1, 394, 15, 16, -1, + 1085, 19, 20, 21, 80, 2716, -1, -1, -1, -1, + -1, 1096, 1097, 1098, -1, 1100, 1101, -1, 36, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 46, 315, + 316, 317, -1, 2189, 2745, 53, -1, 323, -1, -1, + 326, 2752, -1, -1, -1, 2201, -1, -1, -1, -1, + 2206, 1136, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 80, -1, -1, -1, -1, -1, -1, 1154, + 1155, 357, -1, -1, -1, -1, 3, -1, 5, -1, + 366, -1, -1, -1, -1, -1, -1, -1, -1, 2800, + -1, -1, -1, -1, 2250, -1, 382, -1, -1, -1, + 2256, 177, -1, 389, 502, 1190, -1, 393, -1, 1194, + 1195, 509, 510, 511, 512, 513, 514, 403, 194, -1, + 1205, 1206, -1, 199, -1, -1, -1, -1, -1, 415, + -1, -1, -1, 419, -1, -1, -1, 3256, -1, -1, + -1, 68, 69, -1, -1, -1, 222, 223, -1, -1, + -1, -1, -1, 439, -1, -1, -1, -1, 3277, 177, + -1, 237, -1, -1, -1, -1, 452, -1, -1, 455, + -1, 2882, 458, -1, -1, -1, 194, 463, -1, -1, + 1265, 199, 109, 110, -1, 2896, 113, 114, -1, 1274, + -1, -1, -1, -1, 480, -1, -1, -1, -1, 275, + -1, -1, 278, -1, 222, 223, -1, -1, -1, -1, + -1, -1, -1, 1298, -1, -1, 292, -1, 504, 237, + -1, -1, -1, 3342, -1, -1, -1, 2383, -1, -1, + -1, -1, 518, 8, -1, 521, 11, -1, -1, -1, + 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, + -1, -1, -1, 3372, -1, -1, -1, 275, -1, -1, + 278, 36, 189, 190, -1, -1, -1, -1, -1, -1, + -1, 46, -1, -1, 292, -1, -1, 295, 53, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 2560, 177, -1, 2563, -1, 2565, -1, -1, - -1, -1, -1, -1, -1, 2573, -1, -1, -1, -1, - 194, -1, -1, 2581, 2582, 199, -1, -1, -1, -1, - 2588, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 2603, -1, -1, 222, 223, - -1, 177, -1, -1, -1, 2613, -1, -1, -1, -1, - -1, -1, -1, 237, -1, -1, -1, -1, 194, -1, - 177, -1, 1582, 199, -1, 2633, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 194, 1598, -1, - -1, -1, 199, -1, -1, -1, 222, 223, 1608, 1609, - 1610, 275, -1, -1, 278, 1615, -1, -1, -1, 1619, - -1, 237, -1, -1, -1, 222, 223, -1, 292, -1, - -1, 295, -1, -1, -1, 24, -1, -1, -1, -1, - 237, -1, -1, -1, 2692, -1, 2694, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 275, - -1, -1, 278, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 292, -1, 275, 295, - -1, 278, 1682, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 81, -1, -1, 292, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 97, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 1720, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 394, -1, -1, -1, -1, -1, 1736, -1, -1, -1, - -1, 1741, -1, -1, -1, -1, 2794, 2795, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 146, 1758, -1, - -1, -1, -1, -1, -1, -1, -1, 156, -1, -1, + 1385, -1, -1, -1, -1, 80, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 394, -1, - 169, 2829, -1, -1, -1, 174, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 394, -1, -1, - -1, 2849, -1, -1, -1, -1, -1, 2855, 2856, -1, - -1, -1, 2860, -1, 203, -1, -1, 2865, -1, -1, - 2868, 2869, -1, -1, -1, 2873, 2874, 8, -1, 2877, - 11, -1, -1, -1, 15, 16, -1, -1, 502, -1, - 2888, 505, 506, 507, -1, 509, 510, 511, 512, 513, - 514, -1, -1, -1, -1, 519, -1, 246, -1, -1, - -1, 250, -1, -1, -1, 46, -1, -1, -1, -1, - -1, -1, 53, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 2932, -1, 502, -1, -1, 505, - 506, 507, -1, 509, 510, 511, 512, 513, 514, 80, - -1, -1, -1, 519, -1, 502, -1, -1, 505, 506, - 507, 2959, 509, 510, 511, 512, 513, 514, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 1929, - -1, 320, -1, -1, -1, -1, -1, 1937, 1938, -1, - 1940, 1941, 1942, 1943, 1944, 1945, 335, -1, 1948, 1949, - 1950, 1951, 1952, 1953, 1954, 1955, 1956, 1957, 1958, -1, - -1, -1, -1, 8, 145, -1, 11, -1, -1, -1, - 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, - -1, 370, -1, -1, 373, -1, -1, -1, -1, -1, - -1, 36, -1, -1, -1, 384, 177, -1, 387, -1, - -1, 46, -1, -1, -1, -1, -1, -1, 53, -1, - -1, -1, -1, 194, -1, -1, 405, -1, 199, -1, - -1, -1, -1, -1, 3072, -1, -1, -1, -1, -1, - 419, -1, -1, -1, -1, 80, -1, 426, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 436, -1, -1, - -1, 3099, -1, 442, -1, -1, 237, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 2066, -1, -1, 2069, + -1, -1, -1, -1, -1, -1, 253, 254, 255, 256, + 257, 258, 259, 260, -1, 2491, 263, 264, -1, 2495, + -1, -1, -1, -1, -1, 2501, -1, -1, -1, 3060, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 470, -1, -1, -1, 3133, -1, -1, -1, -1, + -1, -1, -1, 1448, -1, 1450, 1451, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 394, -1, 1463, 1464, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 3100, + 2546, -1, -1, -1, 2550, -1, -1, -1, -1, 1484, + -1, -1, 177, -1, -1, -1, -1, -1, -1, -1, + 337, 338, -1, -1, -1, -1, -1, -1, -1, 194, + -1, -1, -1, -1, 199, -1, 502, -1, -1, 505, + 506, 507, -1, 509, 510, 511, 512, 513, 514, -1, + -1, -1, -1, -1, -1, -1, -1, 222, 223, -1, + -1, 378, 379, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 237, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 2634, -1, + -1, -1, 2638, 2639, 502, -1, 2642, 505, 506, 507, + -1, 509, 510, 511, 512, 513, 514, -1, -1, -1, + 275, 1586, -1, 278, 8, -1, -1, 11, -1, 1594, + -1, 15, 16, 2669, -1, -1, -1, 292, -1, -1, + 295, -1, -1, -1, -1, -1, -1, -1, 2684, 2685, + 2686, 2687, 2688, 2689, 2690, 2691, 2692, 2693, -1, -1, + -1, -1, 46, 1628, 3255, -1, -1, 474, 475, 53, + 1635, -1, -1, -1, -1, -1, 1641, 1642, 1643, 1644, + 1645, 1646, 1647, 1648, -1, 3276, -1, -1, 1653, 1654, + -1, 498, 499, 1658, -1, -1, 80, 1662, -1, -1, + 1665, 1666, 1667, 1668, 1669, 1670, 1671, 1672, 1673, -1, + -1, 1676, -1, -1, -1, -1, -1, -1, 1683, 8, + 1685, -1, 11, -1, -1, -1, 15, 16, 17, 18, + 19, 20, 21, -1, -1, -1, -1, -1, 1703, 394, + -1, 3332, -1, 3334, -1, 2781, -1, 36, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 46, -1, -1, + -1, 145, -1, -1, 53, -1, -1, -1, -1, -1, + -1, 2807, 1737, 1738, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 3374, -1, -1, -1, -1, -1, -1, + -1, 80, -1, 177, 8, -1, -1, 11, -1, 3390, + -1, 15, 16, 2839, -1, 19, 20, 21, -1, -1, + 194, 2847, -1, -1, -1, 199, -1, -1, -1, -1, + -1, -1, 36, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 46, -1, -1, -1, -1, -1, -1, 53, + -1, -1, -1, -1, -1, -1, 2882, 502, -1, -1, + 505, 506, 507, 237, 509, 510, 511, 512, 513, 514, + -1, -1, -1, 1828, -1, -1, 80, -1, 523, -1, + 1835, -1, -1, 1838, 1839, -1, -1, -1, -1, 3, + -1, -1, -1, -1, 8, -1, -1, 11, 177, -1, + -1, 15, 16, 17, 18, 19, 20, 21, -1, -1, + -1, -1, -1, -1, 2940, 194, -1, -1, 292, -1, + 199, -1, 36, -1, 1879, -1, 40, -1, -1, -1, + -1, -1, 46, -1, -1, 3516, -1, -1, -1, 53, + -1, -1, -1, 222, 223, -1, -1, -1, -1, 1904, + 1905, -1, -1, -1, -1, -1, -1, -1, 237, -1, + -1, 3542, -1, -1, -1, -1, 80, -1, -1, -1, + -1, -1, -1, 177, -1, -1, -1, -1, 1933, 1934, + -1, 1936, 997, -1, -1, -1, -1, -1, -1, -1, + 194, -1, -1, -1, -1, 199, 275, -1, -1, 278, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 3150, 3151, -1, -1, 3154, -1, 3156, -1, - -1, 292, -1, -1, 2114, -1, -1, -1, 2118, -1, - -1, -1, 2122, 2123, 2124, 2125, 2126, 2127, 2128, 2129, - -1, -1, 177, 3181, -1, 2135, 2136, -1, 2138, 2139, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 194, - -1, -1, 2152, -1, 199, 2155, -1, 3205, -1, -1, - -1, -1, -1, 2163, 2164, 2165, 2166, 2167, 2168, 2169, - 2170, 2171, 2172, -1, -1, -1, -1, 222, 223, -1, + 1965, 1966, -1, 292, 1969, -1, 295, -1, 222, 223, + 394, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 237, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 2000, -1, -1, -1, -1, + -1, -1, 2007, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 177, -1, -1, -1, -1, -1, -1, + 2025, 275, 2027, -1, 278, -1, -1, -1, -1, -1, + 194, -1, -1, -1, -1, 199, -1, -1, 292, -1, + 3116, -1, -1, -1, -1, -1, -1, 3123, -1, -1, + -1, -1, -1, -1, -1, -1, 1121, -1, 222, 223, + 2065, -1, -1, -1, -1, 394, -1, -1, -1, -1, + -1, -1, -1, 237, -1, -1, -1, -1, 502, -1, + -1, -1, -1, -1, -1, 509, 510, 511, 512, 513, + 514, -1, -1, -1, -1, -1, -1, 2102, -1, -1, + -1, 2106, -1, -1, -1, 1170, 2111, 2112, -1, -1, + 3186, 275, -1, -1, 278, 3191, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 292, -1, + -1, 295, -1, -1, -1, -1, -1, -1, -1, 1204, + 394, 3217, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 2158, -1, -1, 2161, -1, 2163, -1, + -1, -1, -1, 3239, 3240, -1, -1, -1, -1, -1, + -1, -1, -1, 502, 2179, -1, 505, 506, 507, -1, + 509, 510, 511, 512, 513, 514, -1, 3263, -1, -1, + -1, -1, -1, 522, 1259, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 237, -1, -1, -1, -1, -1, 2198, -1, + -1, -1, -1, -1, 2219, -1, 8, -1, -1, 11, + -1, -1, -1, 15, 16, -1, -1, -1, 3304, -1, + 394, 2236, 2237, -1, -1, -1, 3312, 1302, -1, -1, + -1, -1, -1, -1, 1309, -1, -1, -1, 502, -1, + 2255, 505, 506, 507, 46, 509, 510, 511, 512, 513, + 514, 53, -1, 2268, -1, 8, -1, -1, 11, -1, + -1, -1, 15, 16, 17, 18, 19, 20, 21, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 80, -1, + -1, -1, -1, 36, 1359, -1, -1, 40, -1, -1, + -1, -1, -1, 46, -1, -1, -1, -1, -1, -1, + 53, -1, -1, -1, -1, -1, -1, -1, 1383, -1, + 2325, -1, -1, -1, -1, -1, -1, -1, -1, 2334, + -1, -1, -1, -1, -1, -1, -1, 80, 502, -1, + -1, 505, 506, 507, -1, 509, 510, 511, 512, 513, + 514, -1, -1, 145, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 1431, -1, 1433, -1, + 1435, 1436, -1, 1438, -1, -1, 1441, -1, -1, 1444, + -1, -1, 1447, -1, -1, 177, -1, 1452, 2393, -1, + 1455, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 194, -1, -1, -1, -1, 199, -1, -1, + -1, -1, -1, -1, 8, -1, -1, 11, -1, 3495, + -1, 15, 16, 17, 18, 19, 20, 21, -1, -1, + -1, -1, -1, 1498, 177, -1, -1, -1, -1, -1, + -1, -1, 36, -1, -1, 237, -1, -1, -1, -1, + -1, 194, 46, -1, -1, -1, 199, -1, -1, 53, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 394, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 222, + 223, -1, -1, -1, -1, -1, 80, -1, -1, -1, + -1, -1, -1, -1, 237, -1, -1, -1, -1, -1, + 292, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 1582, -1, -1, + -1, 2526, -1, -1, -1, -1, -1, 2532, 2533, -1, + -1, -1, 275, 1598, -1, 278, -1, -1, -1, -1, + -1, -1, 2547, 1608, 1609, 1610, -1, -1, -1, 292, + 1615, -1, 295, -1, 1619, -1, -1, -1, 2563, -1, + -1, 2566, -1, 2568, -1, -1, -1, -1, -1, -1, + -1, 2576, -1, -1, -1, -1, -1, -1, -1, 2584, + 2585, -1, -1, 177, -1, -1, 2591, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 275, -1, -1, 278, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 3293, -1, 292, -1, 3297, - 295, 2251, -1, 3301, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 3315, -1, -1, - -1, -1, 3320, -1, 3322, -1, -1, -1, -1, -1, - -1, -1, 3330, -1, -1, -1, -1, -1, -1, -1, + 194, 2606, 394, -1, -1, 199, -1, -1, -1, -1, + -1, 2616, -1, -1, -1, -1, -1, 1682, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 222, 223, + -1, 2636, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 237, -1, -1, -1, -1, -1, -1, + -1, 394, -1, -1, -1, 1720, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 3348, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 1736, -1, -1, -1, -1, 1741, -1, -1, -1, + -1, 275, -1, -1, 278, -1, -1, -1, -1, -1, + 2695, -1, 2697, 1758, -1, -1, -1, -1, 292, -1, + -1, 295, -1, -1, -1, -1, -1, -1, -1, -1, + 502, -1, -1, -1, -1, -1, -1, 509, 510, 511, + 512, 513, 514, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 502, -1, -1, 2324, -1, -1, -1, 509, 510, - 511, 512, 513, 514, 2334, 2335, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 3395, -1, 394, - -1, -1, -1, -1, -1, -1, -1, 3405, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 3417, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 502, + -1, -1, 505, 506, 507, -1, 509, 510, 511, 512, + 513, 514, -1, -1, -1, -1, 519, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 2795, 2796, -1, -1, -1, -1, -1, -1, -1, -1, + 394, -1, -1, -1, 8, -1, -1, 11, -1, -1, + -1, 15, 16, 17, 18, 19, 20, 21, -1, -1, + -1, -1, -1, -1, -1, 2830, -1, -1, -1, -1, + -1, -1, 36, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 46, -1, -1, 2850, -1, -1, -1, 53, + -1, 2856, 2857, -1, -1, -1, 2861, -1, -1, -1, + -1, 2866, -1, -1, 2869, 2870, 1931, -1, -1, 2874, + 2875, -1, -1, 2878, 1939, 1940, 80, 1942, 1943, 1944, + 1945, 1946, 1947, -1, 2889, 1950, 1951, 1952, 1953, 1954, + 1955, 1956, 1957, 1958, 1959, 1960, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 502, -1, + -1, 505, 506, 507, -1, 509, 510, 511, 512, 513, + 514, -1, -1, -1, -1, 519, 68, 69, 2933, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 2401, 3450, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 2427, 2428, 2429, - -1, -1, 2432, 2433, 2434, 2435, 2436, 2437, -1, -1, - -1, 2441, 2442, 2443, 2444, 2445, 2446, 2447, 2448, 2449, - 2450, -1, -1, -1, -1, 2455, 2456, 502, -1, -1, - 505, 506, 507, -1, 509, 510, 511, 512, 513, 514, - -1, -1, -1, -1, 519, -1, -1, -1, -1, -1, - -1, 2481, -1, -1, -1, -1, -1, 2487, -1, 3537, - 3538, 3539, -1, 8, -1, -1, 11, -1, -1, -1, - 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 3564, -1, -1, -1, - -1, 36, 2522, -1, -1, -1, -1, -1, -1, -1, - -1, 46, -1, -1, -1, -1, -1, -1, 53, 2539, - -1, -1, -1, -1, -1, 2545, -1, -1, -1, -1, - -1, -1, -1, 2553, 2554, -1, -1, 3605, -1, -1, - -1, 2561, 2562, -1, -1, 80, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 2575, 2576, 2577, 2578, -1, - 2580, -1, -1, -1, 2584, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 8, -1, - -1, 11, -1, -1, -1, 15, 16, 17, 18, 19, - 20, 21, -1, -1, -1, -1, -1, -1, -1, 68, - 69, -1, -1, -1, -1, -1, 36, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 46, -1, -1, -1, - 2640, -1, -1, 53, -1, -1, -1, -1, -1, -1, + -1, 8, -1, -1, 11, 2960, -1, -1, 15, 16, + 17, 18, 19, 20, 21, -1, -1, 109, 110, -1, + -1, 113, 114, 177, -1, -1, -1, -1, -1, 36, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 46, + 194, -1, -1, -1, -1, 199, 53, -1, -1, -1, + -1, -1, -1, 2068, -1, -1, 2071, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 222, 223, + -1, -1, -1, 80, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 237, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 189, 190, -1, + -1, 2116, -1, -1, -1, 2120, -1, -1, -1, 2124, + 2125, 2126, 2127, 2128, 2129, 2130, 2131, -1, 3073, -1, + -1, 275, 2137, 2138, 278, 2140, 2141, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 292, 2154, + -1, 295, 2157, -1, -1, 3100, -1, -1, -1, -1, + 2165, 2166, 2167, 2168, 2169, 2170, 2171, 2172, 2173, 2174, + -1, 253, 254, 255, 256, 257, 258, 259, 260, -1, + 177, 263, 264, -1, -1, -1, -1, -1, -1, 3134, + -1, -1, -1, -1, -1, 2200, -1, 194, -1, -1, + -1, -1, 199, -1, -1, -1, 3151, 3152, -1, -1, + 3155, -1, 3157, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 222, 223, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 3182, -1, -1, + 237, -1, -1, -1, -1, -1, -1, -1, 2253, -1, + 394, -1, -1, -1, -1, 337, 338, -1, -1, -1, + -1, 3206, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 275, -1, + -1, 278, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 292, 378, 379, 295, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 109, 110, 177, -1, 113, 114, -1, -1, -1, -1, - 80, -1, -1, -1, -1, -1, -1, -1, 8, 194, - -1, 11, -1, -1, 199, 15, 16, 17, 18, 19, - 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 36, 222, 223, -1, - -1, -1, -1, -1, -1, -1, 46, -1, -1, -1, - -1, -1, 237, 53, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 189, 190, -1, -1, -1, -1, -1, -1, -1, -1, - 80, -1, 2752, -1, -1, -1, -1, -1, -1, -1, - 275, -1, -1, 278, -1, -1, -1, 177, -1, -1, - -1, -1, -1, -1, 2774, -1, -1, 292, -1, -1, - 295, -1, -1, -1, 194, -1, -1, -1, 8, 199, - -1, 11, -1, -1, -1, 15, 16, 17, 18, 19, - 20, 21, -1, -1, 253, 254, 255, 256, 257, 258, - 259, 260, 222, 223, 263, 264, 36, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 46, 237, -1, -1, - 2830, -1, 2832, 53, -1, -1, -1, -1, -1, -1, - -1, 2841, -1, -1, -1, -1, -1, 177, -1, 68, - 69, -1, -1, -1, 2854, -1, -1, 2857, -1, 2859, - 80, -1, -1, 2863, 194, 275, 2866, 2867, 278, 199, - 2870, 2871, -1, -1, -1, -1, -1, -1, 2878, 394, - -1, -1, 292, -1, -1, 295, -1, 2887, 337, 338, - 109, 110, 222, 223, 113, 114, -1, -1, -1, -1, - -1, -1, 2902, -1, -1, -1, -1, 237, -1, -1, + -1, 2326, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 2337, 2338, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 3294, + -1, -1, -1, 3298, -1, -1, -1, 3302, 502, -1, + -1, 505, 506, 507, -1, 509, 510, 511, 512, 513, + 514, 3316, -1, -1, -1, 519, 3321, -1, 3323, -1, + -1, -1, -1, -1, -1, -1, 3331, -1, -1, -1, + -1, -1, 474, 475, -1, -1, -1, 394, -1, 2404, + -1, -1, -1, -1, 3349, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 498, 499, -1, -1, + -1, -1, -1, -1, -1, 2430, 2431, 2432, -1, -1, + 2435, 2436, 2437, 2438, 2439, 2440, 518, -1, -1, 2444, + 2445, 2446, 2447, 2448, 2449, 2450, 2451, 2452, 2453, -1, + -1, 3396, -1, 2458, 2459, 8, -1, -1, 11, -1, + -1, 3406, 15, 16, 17, 18, 19, 20, 21, -1, + -1, -1, -1, 3418, -1, -1, -1, -1, -1, 2484, + -1, -1, -1, 36, -1, 2490, -1, -1, -1, -1, + -1, -1, -1, 46, -1, -1, -1, -1, -1, -1, + 53, -1, -1, -1, -1, 502, 3451, -1, 505, 506, + 507, -1, 509, 510, 511, 512, 513, 514, -1, -1, + 2525, -1, 519, -1, -1, -1, -1, 80, -1, -1, + -1, -1, -1, 24, -1, -1, -1, 2542, -1, -1, + -1, -1, -1, 2548, -1, -1, -1, -1, -1, -1, + -1, 2556, 2557, -1, -1, -1, -1, -1, -1, 2564, + 2565, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 2578, 2579, 2580, 2581, -1, 2583, -1, + -1, -1, 2587, -1, -1, -1, -1, -1, -1, -1, + 81, -1, -1, 3538, 3539, 3540, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 97, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 8, + 3565, -1, 11, -1, 177, -1, 15, 16, 17, 18, + 19, 20, 21, -1, -1, -1, -1, -1, 2643, -1, + -1, 194, -1, -1, -1, -1, 199, 36, -1, -1, + -1, -1, -1, -1, -1, 146, -1, 46, -1, -1, + -1, 3606, -1, -1, 53, 156, -1, -1, -1, 222, + 223, -1, -1, -1, -1, -1, -1, -1, 169, -1, + -1, -1, -1, 174, 237, -1, -1, -1, -1, -1, + -1, 80, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 8, -1, + -1, 11, 203, -1, -1, 15, 16, 17, 18, 19, + 20, 21, 275, -1, -1, 278, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 36, -1, -1, 292, + -1, -1, 295, -1, -1, -1, 46, -1, 2753, -1, + -1, -1, -1, 53, -1, 246, -1, -1, -1, 250, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 378, - 379, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 2940, -1, -1, -1, -1, 275, -1, -1, 278, -1, - -1, -1, -1, -1, -1, -1, -1, 177, -1, -1, - -1, -1, 292, -1, -1, 295, -1, -1, -1, -1, - 189, 190, -1, -1, 194, -1, -1, -1, -1, 199, - -1, -1, -1, -1, 394, -1, -1, 502, -1, -1, - 505, 506, 507, -1, 509, 510, 511, 512, 513, 514, - -1, -1, 222, 223, 519, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 237, -1, -1, - -1, -1, -1, -1, -1, 474, 475, -1, -1, -1, - -1, -1, -1, -1, 253, 254, 255, 256, 257, 258, - 259, 260, -1, -1, 263, 264, -1, -1, -1, 498, - 499, -1, -1, -1, -1, 275, -1, -1, 278, -1, - -1, -1, -1, -1, 394, -1, -1, -1, -1, 518, - -1, -1, 292, -1, -1, 295, -1, -1, -1, -1, - -1, -1, 3082, 3083, -1, -1, -1, -1, -1, -1, - -1, -1, 502, -1, -1, 505, 506, 507, -1, 509, - 510, 511, 512, 513, 514, -1, -1, 3107, 3108, 519, - -1, -1, -1, -1, -1, -1, -1, -1, 337, 338, + 2775, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 80, -1, -1, -1, -1, -1, 8, -1, 177, 11, + -1, -1, -1, 15, 16, 17, 18, 19, 20, 21, + -1, -1, -1, -1, -1, 194, -1, -1, -1, -1, + 199, -1, -1, -1, 36, -1, -1, -1, -1, -1, + -1, -1, -1, 314, 46, -1, 2831, -1, 2833, 320, + -1, 53, -1, 222, 223, -1, -1, 2842, -1, -1, + -1, 394, -1, -1, 335, -1, -1, -1, 237, -1, + 2855, -1, -1, 2858, -1, 2860, -1, -1, 80, 2864, + -1, -1, 2867, 2868, -1, -1, 2871, 2872, -1, -1, + -1, -1, -1, -1, 2879, -1, -1, 177, -1, 370, + -1, -1, 373, 2888, -1, -1, 275, -1, -1, 278, + -1, -1, -1, 384, 194, -1, 387, -1, 2903, 199, + -1, -1, -1, 292, -1, -1, 295, -1, -1, -1, + -1, -1, -1, -1, 405, -1, -1, -1, -1, -1, + -1, -1, 222, 223, -1, -1, -1, -1, 419, -1, + -1, -1, -1, -1, 425, 426, 2941, 237, -1, -1, + -1, -1, -1, -1, -1, 436, -1, -1, -1, 502, + -1, 442, 505, 506, 507, 177, 509, 510, 511, 512, + 513, 514, -1, -1, -1, -1, 519, -1, -1, -1, + -1, -1, 194, -1, -1, 275, -1, 199, 278, 470, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 3131, -1, -1, -1, -1, -1, -1, -1, -1, - 3140, -1, -1, -1, 3144, 3145, 3146, -1, -1, 3149, - -1, -1, 3152, 3153, -1, -1, -1, -1, -1, 378, - 379, 3161, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 502, -1, 394, 505, 506, 507, -1, 509, - 510, 511, 512, 513, 514, -1, -1, -1, -1, 519, + 68, 69, 292, -1, -1, 295, -1, -1, -1, -1, + 222, 223, -1, -1, -1, 394, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 237, -1, -1, -1, -1, + -1, -1, -1, -1, 24, -1, -1, -1, -1, -1, + -1, 109, 110, -1, -1, 113, 114, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 3202, -1, -1, -1, -1, -1, 3208, -1, + -1, -1, -1, 275, -1, -1, 278, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 3221, -1, -1, -1, -1, -1, -1, -1, -1, + 292, -1, -1, 295, -1, -1, -1, -1, 3083, 3084, + -1, 81, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 394, -1, -1, 97, -1, -1, + -1, -1, -1, 3108, 3109, -1, -1, -1, -1, -1, + -1, 189, 190, 502, -1, -1, 505, 506, 507, -1, + 509, 510, 511, 512, 513, 514, -1, 3132, -1, -1, + 519, -1, -1, -1, -1, -1, 3141, -1, -1, -1, + 3145, 3146, 3147, -1, -1, 3150, 146, -1, 3153, 3154, + -1, -1, -1, -1, -1, -1, 156, 3162, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 169, + -1, -1, 394, -1, 174, 253, 254, 255, 256, 257, + 258, 259, 260, -1, -1, 263, 264, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 3203, -1, + -1, -1, 502, 203, 3209, 505, 506, 507, -1, 509, + 510, 511, 512, 513, 514, -1, -1, 3222, -1, 519, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 474, 475, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 246, -1, -1, -1, + 250, -1, -1, -1, -1, -1, -1, -1, -1, 337, + 338, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 3282, -1, -1, + 502, -1, -1, 505, 506, 507, -1, 509, 510, 511, + 512, 513, 514, -1, -1, -1, -1, 519, -1, -1, + 378, 379, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 3318, 3319, 3320, -1, -1, -1, -1, + 320, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 3338, -1, 335, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 3350, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 498, - 499, 3281, 502, -1, -1, 505, 506, 507, -1, 509, - 510, 511, 512, 513, 514, -1, -1, -1, -1, 519, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 3317, 3318, 3319, + 370, -1, -1, 373, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 384, -1, -1, 387, -1, -1, + -1, -1, -1, -1, -1, -1, 474, 475, -1, -1, + -1, -1, -1, -1, -1, 405, 3411, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 3421, -1, -1, 419, + 498, 499, -1, -1, -1, -1, 426, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 436, -1, -1, -1, + -1, 3446, 442, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 3337, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 3349, + -1, -1, -1, -1, -1, -1, 3471, -1, -1, -1, + 470, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 3, 4, 5, 6, 7, 8, 9, 10, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 3514, + -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, + 31, 32, 33, -1, -1, -1, -1, -1, 39, -1, + -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 3568, 75, 76, 77, 78, 79, -1, + 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, -1, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, + 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, + 171, 172, 173, 174, 175, 176, 177, 178, -1, 180, + -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, -1, -1, 234, 235, 236, 237, -1, 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, -1, 288, 289, -1, + -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, -1, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, 382, -1, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, 415, -1, 417, 418, 419, 420, + 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, 452, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, 463, 464, 465, -1, 467, 468, 469, 470, + 471, 472, 473, 474, 475, -1, -1, 478, -1, 480, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + 501, 502, -1, 504, -1, -1, -1, -1, 509, 510, + 511, -1, -1, -1, -1, 516, -1, 518, 519, -1, + -1, -1, -1, 524, 525, 526, 527, 3, 4, 5, + 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, + -1, -1, -1, 39, -1, -1, 42, 43, 44, -1, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, -1, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, 81, -1, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, -1, 120, 121, 122, 123, 124, 125, + 126, 127, 128, 129, 130, 131, -1, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, + 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, 171, 172, 173, 174, 175, + 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, -1, -1, 234, 235, + 236, 237, -1, 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, -1, 288, 289, -1, -1, 292, 293, 294, -1, + -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, -1, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, 382, -1, 384, 385, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, + -1, 417, 418, 419, 420, 421, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, 452, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, 465, + -1, 467, 468, 469, 470, 471, 472, 473, 474, 475, + -1, -1, 478, -1, 480, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 501, 502, -1, 504, -1, + -1, -1, -1, 509, 510, 511, -1, -1, -1, -1, + 516, -1, 518, -1, -1, -1, -1, -1, 524, 525, + 526, 527, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, + 31, 32, 33, -1, -1, -1, -1, -1, 39, -1, + -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, + 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, -1, 120, + 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, + 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, + 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, + 171, 172, 173, 174, 175, 176, 177, 178, -1, 180, + -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, -1, -1, 234, 235, 236, 237, -1, 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, -1, 288, 289, -1, + -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, -1, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, 382, -1, 384, 385, 386, 387, 388, 389, 390, + 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, 417, 418, 419, 420, + 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, 452, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, 463, 464, 465, -1, 467, 468, 469, 470, + 471, 472, 473, 474, 475, -1, -1, 478, -1, 480, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + 501, 502, -1, 504, -1, -1, -1, -1, 509, 510, + 511, -1, -1, -1, -1, 516, -1, 518, -1, -1, + -1, -1, -1, 524, 525, 526, 527, 3, 4, 5, + 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, -1, -1, + -1, 37, -1, 39, -1, -1, 42, 43, 44, -1, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, -1, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, 81, -1, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, -1, 120, 121, 122, 123, 124, 125, + -1, -1, 128, 129, 130, 131, 132, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, + 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, 171, -1, 173, 174, 175, + 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, -1, -1, 234, 235, + 236, 237, -1, 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, -1, 288, 289, -1, -1, 292, 293, 294, -1, + 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, -1, 383, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, 394, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, 465, + 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, + -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 501, 502, -1, -1, -1, + -1, -1, -1, 509, 510, 511, -1, -1, -1, -1, + 516, -1, 518, 519, -1, -1, -1, -1, 524, 525, + 526, 527, 3, 4, 5, 6, 7, -1, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, + 31, 32, 33, -1, -1, -1, -1, -1, 39, -1, + -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, + 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, + 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, + 171, 172, 173, 174, 175, 176, 177, 178, -1, 180, + -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, -1, -1, 234, 235, 236, 237, -1, 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, -1, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, + -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, -1, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, 382, -1, 384, 385, 386, 387, 388, 389, 390, + 391, 392, 393, 394, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, 415, -1, 417, 418, 419, 420, + 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, 452, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, 463, 464, 465, -1, 467, 468, 469, 470, + 471, 472, 473, 474, 475, -1, -1, 478, -1, 480, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + 501, -1, -1, 504, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 516, -1, 518, -1, -1, + -1, -1, -1, 524, 525, 526, 527, 3, 4, 5, + 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, + -1, -1, -1, 39, -1, -1, 42, 43, 44, -1, + 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, -1, 75, + 76, 77, 78, 79, -1, 81, -1, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, -1, 120, 121, 122, 123, 124, 125, + -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, + 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, 171, 172, 173, 174, 175, + 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, -1, 233, 234, 235, + 236, 237, -1, 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, -1, 288, 289, -1, -1, 292, 293, 294, -1, + -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, 394, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, 465, + -1, 467, 468, 469, 470, 471, 472, 473, 474, 475, + -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 501, 502, -1, -1, -1, + -1, -1, -1, 509, 510, 511, -1, -1, -1, -1, + 516, -1, 518, -1, -1, -1, -1, -1, 524, 525, + 526, 527, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, + 31, 32, 33, -1, -1, -1, 37, -1, 39, -1, + -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, + 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, -1, 120, + 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, + 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, + 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, + 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, + -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, -1, -1, 234, 235, 236, 237, -1, 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, -1, 288, 289, -1, + -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, -1, 383, 384, 385, 386, 387, 388, 389, 390, + 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, + 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, + 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + 501, 502, -1, -1, -1, -1, -1, -1, 509, 510, + 511, -1, -1, -1, -1, 516, -1, 518, -1, -1, + -1, -1, -1, 524, 525, 526, 527, 3, 4, 5, + 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, + -1, 37, -1, 39, -1, -1, 42, 43, 44, -1, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, -1, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, 81, -1, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, -1, 120, 121, 122, 123, 124, 125, + -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, + 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, 171, -1, 173, 174, 175, + 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, -1, -1, 234, 235, + 236, 237, -1, 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, -1, 288, 289, -1, -1, 292, 293, 294, -1, + -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, -1, 383, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, 394, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, 465, + -1, 467, 468, 469, 470, 471, 472, 473, 474, 475, + -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 501, 502, -1, -1, -1, + -1, -1, -1, 509, 510, 511, -1, -1, -1, -1, + 516, -1, 518, 519, -1, -1, -1, -1, 524, 525, + 526, 527, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, -1, -1, -1, -1, 38, 39, -1, + -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, + 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, -1, 120, + 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, + 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, + 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, + 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, + -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, -1, -1, 234, 235, 236, 237, -1, 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, -1, 288, 289, -1, + -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, + 391, 392, -1, 394, 395, 396, 397, 398, 399, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, + 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, 463, 464, 465, -1, 467, 468, 469, 470, + 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + 501, 502, -1, -1, -1, -1, -1, -1, 509, 510, + 511, -1, -1, -1, -1, 516, -1, 518, -1, -1, + -1, -1, -1, 524, 525, 526, 527, 3, 4, 5, + 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, + -1, 37, -1, 39, -1, -1, 42, 43, 44, -1, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, -1, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, 81, -1, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, -1, 120, 121, 122, 123, 124, 125, + -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, + 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, 171, -1, 173, 174, 175, + 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, -1, -1, 234, 235, + 236, 237, -1, 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, -1, 288, 289, -1, -1, 292, 293, 294, -1, + -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, -1, 383, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, 394, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, 465, + -1, 467, 468, 469, 470, 471, 472, 473, 474, 475, + -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 501, 502, -1, -1, -1, + -1, -1, -1, 509, 510, 511, -1, -1, -1, -1, + 516, -1, 518, 519, -1, -1, -1, -1, 524, 525, + 526, 527, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 3410, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 3420, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 3445, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 3470, -1, -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, 4, 5, 6, - 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 3513, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - -1, -1, 39, -1, -1, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, 3567, 75, 76, - 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, -1, 120, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, 172, 173, 174, 175, 176, - 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - 237, -1, 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, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, -1, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, 382, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, 415, -1, - 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, 452, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, - 467, 468, 469, 470, 471, 472, 473, 474, 475, -1, - -1, 478, -1, 480, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, 502, -1, 504, -1, -1, - -1, -1, 509, 510, 511, -1, -1, -1, -1, 516, - -1, 518, 519, -1, -1, -1, -1, 524, 525, 526, - 527, 3, 4, 5, 6, 7, 8, 9, 10, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, - 32, 33, -1, -1, -1, -1, -1, 39, -1, -1, - 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, - -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, 117, 118, -1, 120, 121, - 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, - -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, - 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, - 172, 173, 174, 175, 176, 177, 178, -1, 180, -1, - 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, - 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - -1, -1, 234, 235, 236, 237, -1, 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, -1, 288, 289, -1, -1, - 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, 315, 316, 317, -1, 319, 320, 321, - 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, - 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, - 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, - 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - 382, -1, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 396, 397, 398, -1, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, 415, -1, 417, 418, 419, 420, 421, - 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, - -1, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, - 452, 453, 454, 455, 456, -1, 458, 459, 460, 461, - 462, 463, 464, 465, -1, 467, 468, 469, 470, 471, - 472, 473, 474, 475, -1, -1, 478, -1, 480, 481, - 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, - 502, -1, 504, -1, -1, -1, -1, 509, 510, 511, - -1, -1, -1, -1, 516, -1, 518, -1, -1, -1, - -1, -1, 524, 525, 526, 527, 3, 4, 5, 6, - 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - -1, -1, 39, -1, -1, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, 172, 173, 174, 175, 176, - 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - 237, -1, 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, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, -1, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, 382, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, 452, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, - 467, 468, 469, 470, 471, 472, 473, 474, 475, -1, - -1, 478, -1, 480, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, 502, -1, 504, -1, -1, - -1, -1, 509, 510, 511, -1, -1, -1, -1, 516, - -1, 518, -1, -1, -1, -1, -1, 524, 525, 526, - 527, 3, 4, 5, 6, 7, 8, 9, 10, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, - 32, 33, -1, -1, -1, 37, -1, 39, -1, -1, - 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, - -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, 117, 118, -1, 120, 121, - 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, - 132, -1, 134, 135, 136, 137, 138, -1, 140, 141, - 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, - -1, 173, 174, 175, 176, 177, 178, -1, 180, -1, - 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, - 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - -1, -1, 234, 235, 236, 237, -1, 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, -1, 288, 289, -1, -1, - 292, 293, 294, -1, 296, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, - 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, - 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, - 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, - 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - -1, 383, 384, 385, 386, 387, 388, 389, 390, 391, - 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, -1, -1, 417, 418, -1, 420, 421, - 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, - -1, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, - -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, - 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, - 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, - 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, - 502, -1, -1, -1, -1, -1, -1, 509, 510, 511, - -1, -1, -1, -1, 516, -1, 518, 519, -1, -1, - -1, -1, 524, 525, 526, 527, 3, 4, 5, 6, - 7, -1, 9, 10, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - -1, -1, 39, -1, -1, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - -1, 118, -1, 120, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, 172, 173, 174, 175, 176, - 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - 237, -1, 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, -1, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, -1, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, 382, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, 415, -1, - 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, 452, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, - 467, 468, 469, 470, 471, 472, 473, 474, 475, -1, - -1, 478, -1, 480, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, -1, -1, 504, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 516, - -1, 518, -1, -1, -1, -1, -1, 524, 525, 526, - 527, 3, 4, 5, 6, 7, 8, 9, 10, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, - 32, 33, -1, -1, -1, -1, -1, 39, -1, -1, - 42, 43, 44, -1, 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, -1, 75, 76, 77, 78, 79, -1, 81, - -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, 117, 118, -1, 120, 121, - 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, - -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, - 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, - 172, 173, 174, 175, 176, 177, 178, -1, 180, -1, - 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, - 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - -1, 233, 234, 235, 236, 237, -1, 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, -1, 288, 289, -1, -1, - 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, - 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, - 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, - 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, - 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, - 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, -1, -1, 417, 418, -1, 420, 421, - 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, - 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, - -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, - 462, 463, 464, 465, -1, 467, 468, 469, 470, 471, - 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, - 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, - 502, -1, -1, -1, -1, -1, -1, 509, 510, 511, - -1, -1, -1, -1, 516, -1, 518, -1, -1, -1, - -1, -1, 524, 525, 526, 527, 3, 4, 5, 6, - 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - 37, -1, 39, -1, -1, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, - 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - 237, -1, 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, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, 383, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, 465, 466, - 467, 468, 469, 470, 471, 472, 473, 474, 475, -1, - -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, 502, -1, -1, -1, -1, - -1, -1, 509, 510, 511, -1, -1, -1, -1, 516, - -1, 518, -1, -1, -1, -1, -1, 524, 525, 526, - 527, 3, 4, 5, 6, 7, 8, 9, 10, -1, + -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, + 31, 32, 33, -1, -1, -1, 37, -1, 39, -1, + -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, + 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, -1, 120, + 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, + 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, + 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, + 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, + -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, -1, -1, 234, 235, 236, 237, -1, 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, -1, 288, 289, -1, + -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, -1, 383, 384, 385, 386, 387, 388, 389, 390, + 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, + 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, 463, 464, 465, -1, 467, 468, 469, 470, + 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + 501, 502, -1, -1, -1, -1, -1, -1, 509, 510, + 511, -1, -1, -1, -1, 516, -1, 518, -1, -1, + -1, -1, -1, 524, 525, 526, 527, 3, 4, 5, + 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, -1, -1, + -1, -1, -1, 39, -1, -1, 42, 43, 44, -1, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, -1, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, 81, -1, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, -1, 120, 121, 122, 123, 124, 125, + -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, + 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, 171, -1, 173, 174, 175, + 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, -1, -1, 234, 235, + 236, 237, -1, 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, -1, 288, 289, -1, -1, 292, 293, 294, -1, + -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, 394, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, 465, + -1, 467, 468, 469, 470, 471, 472, 473, 474, 475, + -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 501, 502, -1, -1, -1, + -1, -1, -1, 509, 510, 511, -1, -1, -1, -1, + 516, -1, 518, -1, -1, -1, -1, -1, 524, 525, + 526, 527, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, - 32, 33, -1, -1, -1, 37, -1, 39, -1, -1, - 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, - -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, 117, 118, -1, 120, 121, - 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, - -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, - 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, - -1, 173, 174, 175, 176, 177, 178, -1, 180, -1, - 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, - 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - -1, -1, 234, 235, 236, 237, -1, 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, -1, 288, 289, -1, -1, - 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, - 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, - 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, - 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, - 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - -1, 383, 384, 385, 386, 387, 388, 389, 390, 391, - 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, -1, -1, 417, 418, -1, 420, 421, - 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, - -1, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, - -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, - 462, 463, 464, 465, -1, 467, 468, 469, 470, 471, - 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, - 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, - 502, -1, -1, -1, -1, -1, -1, 509, 510, 511, - -1, -1, -1, -1, 516, -1, 518, 519, -1, -1, - -1, -1, 524, 525, 526, 527, 3, 4, 5, 6, - 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, -1, -1, -1, - -1, 38, 39, -1, -1, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, - 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - 237, -1, 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, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, - 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, - 467, 468, 469, 470, 471, 472, 473, 474, 475, -1, - -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, 502, -1, -1, -1, -1, - -1, -1, 509, 510, 511, -1, -1, -1, -1, 516, - -1, 518, -1, -1, -1, -1, -1, 524, 525, 526, - 527, 3, 4, 5, 6, 7, 8, 9, 10, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, - 32, 33, -1, -1, -1, 37, -1, 39, -1, -1, - 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, - -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, 117, 118, -1, 120, 121, - 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, - -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, - 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, - -1, 173, 174, 175, 176, 177, 178, -1, 180, -1, - 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, - 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - -1, -1, 234, 235, 236, 237, -1, 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, -1, 288, 289, -1, -1, - 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, - 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, - 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, - 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, - 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - -1, 383, 384, 385, 386, 387, 388, 389, 390, 391, - 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, -1, -1, 417, 418, -1, 420, 421, - 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, - -1, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, - -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, - 462, 463, 464, 465, -1, 467, 468, 469, 470, 471, - 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, - 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, - 502, -1, -1, -1, -1, -1, -1, 509, 510, 511, - -1, -1, -1, -1, 516, -1, 518, 519, -1, -1, - -1, -1, 524, 525, 526, 527, 3, 4, 5, 6, - 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - 37, -1, 39, -1, -1, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, - 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - 237, -1, 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, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, 383, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, - 467, 468, 469, 470, 471, 472, 473, 474, 475, -1, - -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, 502, -1, -1, -1, -1, - -1, -1, 509, 510, 511, -1, -1, -1, -1, 516, - -1, 518, -1, -1, -1, -1, -1, 524, 525, 526, - 527, 3, 4, 5, 6, 7, 8, 9, 10, -1, + -1, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, -1, -1, -1, -1, -1, 39, -1, + -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, + 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, -1, 120, + 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, + 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, + 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, + 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, + -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, -1, -1, 234, 235, 236, 237, -1, 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, -1, 288, 289, -1, + -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, + 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, + 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, 463, 464, 465, -1, 467, 468, 469, 470, + 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + 501, 502, -1, -1, -1, -1, -1, -1, 509, 510, + 511, -1, -1, -1, -1, 516, -1, 518, -1, -1, + -1, -1, -1, 524, 525, 526, 527, 3, 4, 5, + 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, + -1, -1, -1, 39, -1, -1, 42, 43, 44, -1, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, -1, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, 81, -1, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, -1, 120, 121, 122, 123, 124, 125, + -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, + 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, 171, 172, 173, 174, 175, + 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, -1, -1, 234, 235, + 236, 237, -1, 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, -1, 288, 289, -1, -1, 292, 293, 294, -1, + -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, 394, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, 465, + -1, 467, 468, 469, 470, 471, 472, 473, 474, 475, + -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 501, 502, -1, -1, -1, + -1, -1, -1, 509, 510, 511, -1, -1, -1, -1, + 516, -1, 518, -1, -1, -1, -1, -1, 524, 525, + 526, 527, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, - 32, 33, -1, -1, -1, -1, -1, 39, -1, -1, - 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, - -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, 117, 118, -1, 120, 121, - 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, - -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, - 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, - -1, 173, 174, 175, 176, 177, 178, -1, 180, -1, - 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, - 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - -1, -1, 234, 235, 236, 237, -1, 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, -1, 288, 289, -1, -1, - 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, - 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, - 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, - 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, - 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, - 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, -1, -1, 417, 418, -1, 420, 421, - 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, - -1, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, - -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, - 462, 463, 464, 465, -1, 467, 468, 469, 470, 471, - 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, - 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, - 502, -1, -1, -1, -1, -1, -1, 509, 510, 511, - -1, -1, -1, -1, 516, -1, 518, -1, -1, -1, - -1, -1, 524, 525, 526, 527, 3, 4, 5, 6, - 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, -1, -1, -1, - -1, -1, 39, -1, -1, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, - 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - 237, -1, 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, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, - 467, 468, 469, 470, 471, 472, 473, 474, 475, -1, - -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, 502, -1, -1, -1, -1, - -1, -1, 509, 510, 511, -1, -1, -1, -1, 516, - -1, 518, -1, -1, -1, -1, -1, 524, 525, 526, - 527, 3, 4, 5, 6, 7, 8, 9, 10, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, - 32, 33, -1, -1, -1, -1, -1, 39, -1, -1, - 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, - -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, 117, 118, -1, 120, 121, - 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, - -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, - 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, - 172, 173, 174, 175, 176, 177, 178, -1, 180, -1, - 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, - 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - -1, -1, 234, 235, 236, 237, -1, 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, -1, 288, 289, -1, -1, - 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, - 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, - 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, - 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, - 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, - 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, -1, -1, 417, 418, -1, 420, 421, - 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, - -1, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, - -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, - 462, 463, 464, 465, -1, 467, 468, 469, 470, 471, - 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, - 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, - 502, -1, -1, -1, -1, -1, -1, 509, 510, 511, - -1, -1, -1, -1, 516, -1, 518, -1, -1, -1, - -1, -1, 524, 525, 526, 527, 3, 4, 5, 6, - 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - -1, -1, 39, -1, -1, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, - 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - 237, -1, 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, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, - 467, 468, 469, 470, 471, 472, 473, 474, 475, -1, - -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, 502, -1, -1, -1, -1, - -1, -1, 509, 510, 511, -1, -1, -1, -1, 516, - -1, 518, 519, -1, -1, -1, -1, 524, 525, 526, - 527, 3, 4, 5, 6, 7, 8, 9, 10, -1, + -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, + 31, 32, 33, -1, -1, -1, -1, -1, 39, -1, + -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, + 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, -1, 120, + 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, + 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, + 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, + 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, + -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, -1, -1, 234, 235, 236, 237, -1, 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, -1, 288, 289, -1, + -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, + 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, + 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, 463, 464, 465, -1, 467, 468, 469, 470, + 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + 501, 502, -1, -1, -1, -1, -1, -1, 509, 510, + 511, -1, -1, -1, -1, 516, -1, 518, 519, -1, + -1, -1, -1, 524, 525, 526, 527, 3, 4, 5, + 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, + -1, -1, -1, 39, -1, -1, 42, 43, 44, -1, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, -1, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, 81, -1, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, -1, 120, 121, 122, 123, 124, 125, + -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, + 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, 171, -1, 173, 174, 175, + 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, -1, -1, 234, 235, + 236, 237, -1, 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, -1, 288, 289, -1, -1, 292, 293, 294, -1, + -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, 394, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, 465, + -1, 467, 468, 469, 470, 471, 472, 473, 474, 475, + -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 501, 502, -1, -1, -1, + -1, -1, -1, 509, 510, 511, -1, -1, -1, -1, + 516, -1, 518, -1, -1, -1, -1, 523, 524, 525, + 526, 527, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, - 32, 33, -1, -1, -1, -1, -1, 39, -1, -1, - 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, - -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, 117, 118, -1, 120, 121, - 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, - -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, - 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, - -1, 173, 174, 175, 176, 177, 178, -1, 180, -1, - 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, - 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - -1, -1, 234, 235, 236, 237, -1, 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, -1, 288, 289, -1, -1, - 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, - 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, - 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, - 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, - 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, - 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, -1, -1, 417, 418, -1, 420, 421, - 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, - -1, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, - -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, - 462, 463, 464, 465, -1, 467, 468, 469, 470, 471, - 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, - 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, - 502, -1, -1, -1, -1, -1, -1, 509, 510, 511, - -1, -1, -1, -1, 516, -1, 518, -1, -1, -1, - -1, 523, 524, 525, 526, 527, 3, 4, 5, 6, - 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - -1, -1, 39, -1, -1, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, - 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - 237, -1, 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, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, - 467, 468, 469, 470, 471, 472, 473, 474, 475, -1, - -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, 502, -1, -1, -1, -1, - -1, -1, 509, 510, 511, -1, -1, -1, -1, 516, - -1, 518, -1, -1, -1, -1, -1, 524, 525, 526, - 527, 3, 4, 5, 6, 7, 8, 9, 10, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, - 32, 33, -1, -1, -1, -1, -1, 39, -1, -1, - 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, - -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, 117, 118, -1, 120, 121, - 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, - -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, - 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, - -1, 173, 174, 175, 176, 177, 178, -1, 180, -1, - 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, - 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - -1, -1, 234, 235, 236, 237, -1, 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, -1, 288, 289, -1, -1, - 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, - 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, - 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, - 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, - 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, - 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, -1, -1, 417, 418, -1, 420, 421, - 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, - -1, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, - -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, - 462, 463, 464, 465, -1, 467, 468, 469, 470, 471, - 472, 473, 474, 475, -1, 477, 478, -1, -1, 481, - 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, - 502, -1, -1, -1, -1, -1, -1, 509, 510, 511, - -1, -1, -1, -1, 516, -1, 518, -1, -1, -1, - -1, -1, 524, 525, 526, 527, 3, 4, 5, 6, - 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, -1, -1, -1, - -1, -1, 39, -1, -1, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, - 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - 237, -1, 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, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, - 467, 468, 469, 470, 471, 472, 473, 474, 475, -1, - -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, 502, -1, -1, -1, -1, - -1, -1, 509, 510, 511, -1, -1, -1, -1, 516, - -1, 518, -1, -1, -1, -1, -1, 524, 525, 526, - 527, 3, 4, 5, 6, 7, 8, 9, 10, -1, + -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, + 31, 32, 33, -1, -1, -1, -1, -1, 39, -1, + -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, + 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, -1, 120, + 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, + 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, + 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, + 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, + -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, -1, -1, 234, 235, 236, 237, -1, 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, -1, 288, 289, -1, + -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, + 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, 417, 418, 419, 420, + 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, 463, 464, 465, -1, 467, 468, 469, 470, + 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + 501, 502, -1, -1, -1, -1, -1, -1, 509, 510, + 511, -1, -1, -1, -1, 516, -1, 518, -1, -1, + -1, -1, -1, 524, 525, 526, 527, 3, 4, 5, + 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, + -1, -1, -1, 39, -1, -1, 42, 43, 44, -1, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, -1, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, 81, -1, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, -1, 120, 121, 122, 123, 124, 125, + -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, + 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, 171, -1, 173, 174, 175, + 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, -1, -1, 234, 235, + 236, 237, -1, 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, -1, 288, 289, -1, -1, 292, 293, 294, -1, + -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, 394, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, 465, + -1, 467, 468, 469, 470, 471, 472, 473, 474, 475, + -1, 477, 478, -1, -1, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 501, 502, -1, -1, -1, + -1, -1, -1, 509, 510, 511, -1, -1, -1, -1, + 516, -1, 518, -1, -1, -1, -1, -1, 524, 525, + 526, 527, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, - 32, 33, -1, -1, -1, -1, -1, 39, -1, -1, - 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, - -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, 117, 118, -1, 120, 121, - 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, - -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, - 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, - -1, 173, 174, 175, 176, 177, 178, -1, 180, -1, - 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, - 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - -1, -1, 234, 235, 236, 237, -1, 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, -1, 288, 289, -1, -1, - 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, - 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, - 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, - 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, - 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, - 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, -1, -1, 417, 418, -1, 420, 421, - 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, - -1, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, - -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, - 462, 463, 464, 465, -1, 467, 468, 469, 470, 471, - 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, - 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, - 502, -1, -1, -1, -1, -1, -1, 509, 510, 511, - -1, -1, -1, -1, 516, -1, 518, -1, -1, -1, - -1, 523, 524, 525, 526, 527, 3, 4, 5, 6, - 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - -1, -1, 39, -1, -1, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, - 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - 237, -1, 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, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, - 467, 468, 469, 470, 471, 472, 473, 474, 475, -1, - -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, 502, -1, -1, -1, -1, - -1, -1, 509, 510, 511, -1, -1, -1, -1, 516, - -1, 518, -1, -1, -1, -1, -1, 524, 525, 526, - 527, 3, 4, 5, 6, 7, 8, 9, 10, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, - 32, 33, -1, -1, -1, -1, -1, 39, -1, -1, - 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, - -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, 117, 118, -1, 120, 121, - 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, - -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, - 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, - -1, 173, 174, 175, 176, 177, 178, -1, 180, -1, - 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, - 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - -1, -1, 234, 235, 236, 237, -1, 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, -1, 288, 289, -1, -1, - 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, - 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, - 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, - 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, - 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, - 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, -1, -1, 417, 418, -1, 420, 421, - 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, - -1, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, - -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, - 462, 463, 464, 465, -1, 467, 468, 469, 470, 471, - 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, - 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, - 502, -1, -1, -1, -1, -1, -1, 509, 510, 511, - -1, -1, -1, -1, 516, -1, 518, -1, -1, -1, - -1, -1, 524, 525, 526, 527, 3, 4, 5, 6, - 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - -1, -1, 39, -1, -1, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, - 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - 237, -1, 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, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, - 467, 468, 469, 470, 471, 472, 473, 474, 475, -1, - -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, 502, -1, -1, -1, -1, - -1, -1, 509, 510, 511, -1, -1, -1, -1, 516, - -1, 518, -1, -1, -1, -1, -1, 524, 525, 526, - 527, 3, 4, 5, 6, 7, 8, 9, 10, -1, + -1, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, -1, -1, -1, -1, -1, 39, -1, + -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, + 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, -1, 120, + 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, + 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, + 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, + 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, + -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, -1, -1, 234, 235, 236, 237, -1, 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, -1, 288, 289, -1, + -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, + 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, + 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, 463, 464, 465, -1, 467, 468, 469, 470, + 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + 501, 502, -1, -1, -1, -1, -1, -1, 509, 510, + 511, -1, -1, -1, -1, 516, -1, 518, -1, -1, + -1, -1, -1, 524, 525, 526, 527, 3, 4, 5, + 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, + -1, -1, -1, 39, -1, -1, 42, 43, 44, -1, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, -1, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, 81, -1, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, -1, 120, 121, 122, 123, 124, 125, + -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, + 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, 171, -1, 173, 174, 175, + 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, -1, -1, 234, 235, + 236, 237, -1, 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, -1, 288, 289, -1, -1, 292, 293, 294, -1, + -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, 394, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, 465, + -1, 467, 468, 469, 470, 471, 472, 473, 474, 475, + -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 501, 502, -1, -1, -1, + -1, -1, -1, 509, 510, 511, -1, -1, -1, -1, + 516, -1, 518, -1, -1, -1, -1, 523, 524, 525, + 526, 527, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, - 32, 33, -1, -1, -1, -1, -1, 39, -1, -1, - 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, - -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, 117, 118, -1, 120, 121, - 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, - -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, - 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, - -1, 173, 174, 175, 176, 177, 178, -1, 180, -1, - 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, - 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - -1, -1, 234, 235, 236, 237, -1, 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, -1, 288, 289, -1, -1, - 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, - 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, - 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, - 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, - 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, - 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, -1, -1, 417, 418, -1, 420, 421, - 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, - -1, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, - -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, - 462, 463, 464, 465, -1, 467, 468, 469, 470, 471, - 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, - 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, - 502, -1, -1, -1, -1, -1, -1, 509, 510, 511, - -1, -1, -1, -1, 516, -1, 518, -1, -1, -1, - -1, -1, 524, 525, 526, 527, 3, 4, 5, 6, - 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - -1, -1, 39, -1, -1, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, - 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - 237, -1, 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, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, - 467, 468, 469, 470, 471, 472, 473, 474, 475, -1, - -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, 502, -1, -1, -1, -1, - -1, -1, 509, 510, 511, -1, -1, -1, -1, 516, - -1, 518, -1, -1, -1, -1, -1, 524, 525, 526, - 527, 3, 4, 5, 6, 7, 8, 9, 10, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, - 32, 33, -1, -1, -1, -1, -1, 39, -1, -1, - 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, - -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, 117, 118, -1, 120, 121, - 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, - -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, - 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, - -1, 173, 174, 175, 176, 177, 178, -1, 180, -1, - 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, - 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - -1, -1, 234, 235, 236, 237, -1, 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, -1, 288, 289, -1, -1, - 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, - 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, - 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, - 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, - 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, - 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, -1, -1, 417, 418, -1, 420, 421, - 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, - -1, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, - -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, - 462, 463, 464, 465, -1, 467, 468, 469, 470, 471, - 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, - 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, - 502, -1, -1, -1, -1, -1, -1, 509, 510, 511, - -1, -1, -1, -1, 516, -1, 518, -1, -1, -1, - -1, -1, 524, 525, 526, 527, 3, 4, 5, 6, - 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - -1, -1, 39, -1, -1, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, - 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - 237, -1, 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, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, - 467, 468, 469, 470, 471, 472, 473, 474, 475, -1, - -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, 502, -1, -1, -1, -1, - -1, -1, 509, 510, 511, -1, -1, -1, -1, 516, - -1, 518, -1, -1, -1, -1, -1, 524, 525, 526, - 527, 3, 4, 5, 6, 7, 8, 9, 10, -1, + -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, + 31, 32, 33, -1, -1, -1, -1, -1, 39, -1, + -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, + 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, -1, 120, + 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, + 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, + 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, + 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, + -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, -1, -1, 234, 235, 236, 237, -1, 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, -1, 288, 289, -1, + -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, + 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, + 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, 463, 464, 465, -1, 467, 468, 469, 470, + 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + 501, 502, -1, -1, -1, -1, -1, -1, 509, 510, + 511, -1, -1, -1, -1, 516, -1, 518, -1, -1, + -1, -1, -1, 524, 525, 526, 527, 3, 4, 5, + 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, + -1, -1, -1, 39, -1, -1, 42, 43, 44, -1, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, -1, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, 81, -1, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, -1, 120, 121, 122, 123, 124, 125, + -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, + 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, 171, -1, 173, 174, 175, + 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, -1, -1, 234, 235, + 236, 237, -1, 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, -1, 288, 289, -1, -1, 292, 293, 294, -1, + -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, 394, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, 465, + -1, 467, 468, 469, 470, 471, 472, 473, 474, 475, + -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 501, 502, -1, -1, -1, + -1, -1, -1, 509, 510, 511, -1, -1, -1, -1, + 516, -1, 518, -1, -1, -1, -1, -1, 524, 525, + 526, 527, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, - 32, 33, -1, -1, -1, -1, -1, 39, -1, -1, - 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, - -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, 117, 118, -1, 120, 121, - 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, - -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, - 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, - -1, 173, 174, 175, 176, 177, 178, -1, 180, -1, - 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, - 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - -1, -1, 234, 235, 236, 237, -1, 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, -1, 288, 289, -1, -1, - 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, - 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, - 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, - 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, - 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, - 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, -1, -1, 417, 418, -1, 420, 421, - 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, - -1, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, - -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, - 462, 463, 464, 465, -1, 467, 468, 469, 470, 471, - 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, - 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, - 502, -1, -1, -1, -1, -1, -1, 509, 510, 511, - -1, -1, -1, -1, 516, -1, 518, -1, -1, -1, - -1, -1, 524, 525, 526, 527, 3, 4, 5, 6, - 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - -1, -1, 39, -1, -1, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, - 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - 237, -1, 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, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, - 467, 468, 469, 470, 471, 472, 473, 474, 475, -1, - -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, 502, -1, -1, -1, -1, - -1, -1, 509, 510, 511, -1, -1, -1, -1, 516, - -1, 518, -1, -1, -1, -1, -1, 524, 525, 526, - 527, 3, 4, 5, 6, 7, 8, 9, 10, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, - 32, 33, -1, -1, -1, -1, -1, 39, -1, -1, - 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, - -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, - 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, - -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, - 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, - -1, 173, 174, 175, 176, 177, 178, -1, 180, -1, - 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, - 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - -1, -1, 234, 235, 236, 237, -1, 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, -1, 276, 277, 278, 279, 280, 281, - 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, - 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, - 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, - 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, - 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, - 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, - 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, -1, -1, 417, 418, -1, 420, 421, - 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, - -1, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, - -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, - 462, 463, 464, 465, -1, 467, 468, 469, 470, 471, - 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, - 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, - -1, -1, -1, -1, -1, -1, -1, 509, 510, -1, - -1, -1, -1, -1, 516, -1, 518, -1, -1, -1, - -1, -1, 524, 525, 526, 527, 3, 4, 5, 6, - 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - -1, -1, 39, -1, -1, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, - 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, -1, -1, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - 237, -1, 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, -1, 276, - 277, -1, 279, 280, 281, 282, 283, 284, 285, 286, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, - 467, 468, 469, 470, 471, 472, 473, 474, 475, -1, - -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, 502, -1, -1, -1, -1, - -1, -1, 509, 510, 511, -1, -1, -1, -1, 516, - -1, 518, -1, -1, -1, -1, -1, 524, 525, 526, - 527, 3, 4, 5, 6, 7, -1, 9, 10, -1, + -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, + 31, 32, 33, -1, -1, -1, -1, -1, 39, -1, + -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, + 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, -1, 120, + 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, + 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, + 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, + 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, + -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, -1, -1, 234, 235, 236, 237, -1, 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, -1, 288, 289, -1, + -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, + 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, + 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, 463, 464, 465, -1, 467, 468, 469, 470, + 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + 501, 502, -1, -1, -1, -1, -1, -1, 509, 510, + 511, -1, -1, -1, -1, 516, -1, 518, -1, -1, + -1, -1, -1, 524, 525, 526, 527, 3, 4, 5, + 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, + -1, -1, -1, 39, -1, -1, 42, 43, 44, -1, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, -1, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, 81, -1, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, -1, 120, 121, 122, 123, 124, 125, + -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, + 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, 171, -1, 173, 174, 175, + 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, -1, -1, 234, 235, + 236, 237, -1, 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, -1, 288, 289, -1, -1, 292, 293, 294, -1, + -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, 394, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, 465, + -1, 467, 468, 469, 470, 471, 472, 473, 474, 475, + -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 501, 502, -1, -1, -1, + -1, -1, -1, 509, 510, 511, -1, -1, -1, -1, + 516, -1, 518, -1, -1, -1, -1, -1, 524, 525, + 526, 527, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, - 32, 33, -1, -1, -1, -1, -1, 39, -1, -1, - 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, - -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, - 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, - -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, - 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, - -1, 173, 174, 175, 176, 177, 178, -1, 180, -1, - 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, - 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - -1, -1, 234, 235, 236, 237, -1, 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, -1, 276, 277, 278, 279, 280, 281, - 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, - 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, - 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, - 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, - 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, - 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, - 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, -1, -1, 417, 418, -1, 420, 421, - 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, - -1, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, - -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, - 462, 463, 464, 465, -1, 467, 468, 469, 470, 471, - 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, - 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, - -1, -1, -1, -1, -1, -1, -1, 509, 510, -1, - -1, -1, -1, -1, 516, -1, 518, -1, -1, -1, - -1, -1, 524, 525, 526, 527, 3, 4, 5, 6, - 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - -1, -1, 39, -1, -1, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, - 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, -1, 223, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - 237, -1, 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, -1, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, - 467, 468, 469, 470, 471, 472, 473, 474, 475, -1, - -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, -1, -1, -1, -1, -1, - -1, -1, 509, 510, -1, -1, -1, -1, -1, 516, - -1, 518, -1, -1, -1, -1, -1, 524, 525, 526, - 527, 3, 4, 5, 6, 7, -1, 9, 10, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, - 32, 33, -1, -1, -1, -1, -1, 39, -1, -1, - 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, - -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, - 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, - -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, - 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, - -1, 173, 174, 175, 176, 177, 178, -1, 180, 181, - 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, - 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - -1, -1, 234, 235, 236, 237, -1, 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, -1, 276, 277, 278, 279, 280, 281, - 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, - 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, - 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, - 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, - 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, - 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, - 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, -1, -1, 417, 418, -1, 420, 421, - 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, - -1, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, - -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, - 462, 463, 464, 465, -1, 467, 468, 469, 470, 471, - 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, - 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 516, -1, 518, -1, -1, -1, - -1, -1, 524, 525, 526, 527, 3, 4, 5, 6, - 7, -1, 9, 10, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - -1, -1, 39, -1, -1, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, - 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - 237, -1, 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, -1, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, - 467, 468, 469, 470, 471, 472, 473, 474, 475, -1, - -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 516, - -1, 518, -1, -1, -1, -1, -1, 524, 525, 526, - 527, 3, 4, 5, 6, 7, -1, 9, 10, -1, + -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, + 31, 32, 33, -1, -1, -1, -1, -1, 39, -1, + -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, + 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, -1, 120, + 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, + 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, + 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, + 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, + -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, -1, -1, 234, 235, 236, 237, -1, 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, -1, 288, 289, -1, + -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, + 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, + 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, 463, 464, 465, -1, 467, 468, 469, 470, + 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + 501, 502, -1, -1, -1, -1, -1, -1, 509, 510, + 511, -1, -1, -1, -1, 516, -1, 518, -1, -1, + -1, -1, -1, 524, 525, 526, 527, 3, 4, 5, + 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, + -1, -1, -1, 39, -1, -1, 42, 43, 44, -1, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, -1, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, 81, -1, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, -1, 120, 121, 122, 123, 124, 125, + -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, + 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, 171, -1, 173, 174, 175, + 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, -1, -1, 234, 235, + 236, 237, -1, 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, -1, 288, 289, -1, -1, 292, 293, 294, -1, + -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, 394, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, 465, + -1, 467, 468, 469, 470, 471, 472, 473, 474, 475, + -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 501, 502, -1, -1, -1, + -1, -1, -1, 509, 510, 511, -1, -1, -1, -1, + 516, -1, 518, -1, -1, -1, -1, -1, 524, 525, + 526, 527, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, - 32, 33, -1, -1, -1, -1, -1, 39, -1, -1, - 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, - -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, - 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, - -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, - 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, - -1, 173, 174, 175, 176, 177, 178, -1, 180, -1, - 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, - 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - -1, -1, 234, 235, 236, 237, -1, 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, -1, 276, 277, 278, 279, 280, 281, - 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, - 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, - 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, - 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, - 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, - 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, - 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, -1, -1, 417, 418, -1, 420, 421, - 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, - -1, 433, 434, 435, 436, 437, 438, 439, 440, 441, - 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, - -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, - 462, 463, 464, 465, -1, 467, 468, 469, 470, 471, - 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, - 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, + -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, + 31, 32, 33, -1, -1, -1, -1, -1, 39, -1, + -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, + 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, -1, 120, + 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, + 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, + 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, + 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, + -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, -1, -1, 234, 235, 236, 237, -1, 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, -1, 288, 289, -1, + -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, + 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, + 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, 463, 464, 465, -1, 467, 468, 469, 470, + 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + 501, 502, -1, -1, -1, -1, -1, -1, 509, 510, + 511, -1, -1, -1, -1, 516, -1, 518, -1, -1, + -1, -1, -1, 524, 525, 526, 527, 3, 4, 5, + 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, + -1, -1, -1, 39, -1, -1, 42, 43, 44, -1, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, -1, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, 81, -1, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, -1, 120, 121, 122, 123, 124, 125, + -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, + 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, 171, -1, 173, 174, 175, + 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, -1, -1, 234, 235, + 236, 237, -1, 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, -1, 288, 289, -1, -1, 292, 293, 294, -1, + -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, 394, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, 465, + -1, 467, 468, 469, 470, 471, 472, 473, 474, 475, + -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 501, 502, -1, -1, -1, + -1, -1, -1, 509, 510, 511, -1, -1, -1, -1, + 516, -1, 518, -1, -1, -1, -1, -1, 524, 525, + 526, 527, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 516, -1, 518, -1, -1, -1, - -1, -1, 524, 525, 526, 527, 3, 4, 5, 6, - 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - -1, -1, 39, -1, -1, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, -1, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, -1, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, - -1, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, -1, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, -1, -1, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - -1, -1, 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, -1, 276, - 277, -1, 279, 280, 281, 282, 283, 284, 285, 286, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, -1, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, - 467, 468, 469, 470, 471, 472, 473, 474, 475, -1, - -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, -1, -1, -1, -1, -1, - -1, -1, 509, 510, 511, -1, 3, 4, 5, 516, - -1, 518, 9, -1, -1, -1, -1, 524, 525, 526, - 527, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - 37, -1, -1, -1, -1, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, - 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - 237, -1, 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, -1, 276, - 277, 278, 279, -1, 281, 282, 283, 284, 285, 286, - -1, 288, 289, 290, -1, 292, 293, 294, -1, -1, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, 383, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, - 467, 468, 469, 470, 471, 472, 473, 474, 475, -1, - -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, -1, -1, -1, -1, -1, - -1, -1, 509, 510, 511, 3, -1, -1, -1, 516, - -1, 518, 10, -1, -1, -1, -1, -1, -1, -1, - 527, -1, -1, -1, 22, 23, 24, 25, 26, 27, - 28, 29, -1, 31, 32, 33, -1, -1, -1, -1, - -1, 39, -1, -1, 42, 43, 44, -1, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - -1, 59, 60, 61, 62, 63, 64, 65, 66, 67, - 68, 69, 70, 71, 72, 73, -1, 75, 76, 77, - 78, 79, -1, 81, -1, 83, 84, 85, 86, 87, - 88, 89, 90, 91, 92, -1, 94, 95, 96, 97, - 98, 99, -1, 101, 102, 103, 104, 105, 106, 107, - 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, - 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, - 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, - 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, - 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, -1, 161, -1, 163, 164, 165, 166, -1, - 168, -1, 170, 171, -1, 173, 174, 175, 176, 177, - 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 198, -1, 200, 201, 202, 203, 204, 205, 206, -1, - 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, - -1, 219, -1, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, -1, -1, 234, 235, 236, 237, - -1, 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, -1, 276, 277, - 278, 279, -1, 281, 282, 283, 284, 285, 286, -1, - 288, 289, -1, -1, 292, 293, 294, -1, -1, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, - -1, 319, 320, 321, 322, 323, 324, 325, 326, 327, - 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, - 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, -1, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, 379, 380, 381, -1, -1, 384, 385, 386, 387, - 388, 389, 390, 391, 392, -1, 394, 395, 396, 397, - 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, 412, 413, 414, -1, -1, 417, - 418, -1, 420, 421, 422, 423, 424, 425, 426, -1, - 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, - -1, 439, 440, 441, 442, 443, 444, 445, 446, -1, - -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, - 458, 459, 460, 461, 462, 463, 464, 465, -1, 467, - 468, 469, 470, 471, 472, 473, 474, 475, -1, -1, - 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 498, 499, 500, 501, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 3, 4, -1, 516, -1, - 518, 9, 10, -1, -1, -1, 524, 525, 526, 527, - -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, - 28, 29, -1, 31, 32, 33, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 43, 44, -1, 46, 47, - 48, -1, 50, 51, 52, 53, 54, -1, 56, 57, - -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, - 68, 69, 70, 71, 72, 73, -1, 75, 76, 77, - 78, 79, -1, -1, -1, 83, 84, 85, 86, 87, - 88, -1, 90, 91, 92, -1, 94, 95, 96, 97, - 98, 99, -1, -1, 102, 103, 104, 105, 106, 107, - 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, - 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, - 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, - 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, - 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, -1, 161, -1, 163, 164, 165, 166, -1, - 168, -1, 170, -1, -1, -1, 174, 175, 176, -1, - 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, - 188, 189, 190, 191, 192, 193, -1, 195, 196, 197, - 198, -1, 200, 201, 202, 203, 204, 205, 206, -1, - 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, - -1, 219, -1, 221, -1, -1, 224, -1, 226, 227, - 228, 229, 230, 231, -1, -1, 234, -1, 236, -1, - -1, 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, -1, 270, 271, 272, 273, 274, -1, 276, 277, - -1, 279, -1, 281, 282, 283, 284, 285, 286, -1, - 288, 289, -1, -1, 292, 293, 294, -1, -1, 297, - 298, 299, -1, 301, -1, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, - -1, 319, 320, 321, -1, 323, 324, 325, 326, 327, - 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, - 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, -1, 362, 363, -1, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, 379, 380, 381, -1, -1, 384, 385, 386, 387, - 388, 389, 390, 391, 392, -1, -1, 395, 396, 397, - 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, 412, 413, 414, -1, -1, 417, - 418, -1, 420, -1, 422, 423, 424, 425, 426, -1, - 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, - -1, 439, 440, 441, 442, 443, 444, 445, 446, -1, - -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, - 458, 459, 460, 461, 462, 463, 464, 465, -1, 467, - -1, 469, 470, 471, 472, 473, 474, 475, -1, -1, - 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 498, 499, 500, 501, -1, -1, -1, -1, -1, 3, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 524, 525, 22, 23, - 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, - -1, -1, -1, -1, -1, -1, 40, -1, -1, 43, - 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, - 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, - 64, -1, -1, 67, 68, 69, 70, 71, 72, 73, - -1, 75, 76, 77, 78, 79, -1, -1, -1, 83, - 84, 85, 86, 87, 88, -1, 90, 91, 92, -1, - 94, 95, 96, 97, 98, 99, -1, -1, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, - 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, - 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, - 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, -1, 161, 162, 163, - 164, 165, 166, 167, 168, -1, 170, -1, -1, -1, - 174, 175, 176, -1, 178, -1, 180, -1, 182, 183, - 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, - -1, 195, 196, 197, 198, -1, 200, 201, 202, 203, - 204, 205, 206, -1, 208, -1, 210, 211, 212, 213, - 214, 215, 216, 217, 218, 219, -1, 221, -1, -1, - 224, -1, 226, 227, 228, 229, 230, 231, -1, -1, - 234, -1, 236, -1, 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, -1, 270, 271, 272, 273, - 274, -1, 276, 277, -1, 279, -1, 281, 282, 283, - 284, 285, 286, 287, 288, 289, -1, -1, 292, 293, - 294, -1, 296, 297, 298, 299, -1, 301, -1, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, -1, -1, -1, -1, 319, 320, 321, -1, 323, - 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, - 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, - 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, - -1, 365, 366, 367, 368, 369, 370, 371, 372, 373, - 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, - 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, - -1, 395, 396, 397, 398, -1, 400, 401, 402, 403, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, -1, -1, 417, 418, -1, 420, -1, 422, 423, - 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, - 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, - 444, 445, 446, 447, -1, 449, 450, 451, -1, 453, - 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, - 464, 465, -1, 467, -1, 469, 470, 471, 472, 473, - 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, - 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, - 494, 495, 496, 497, 498, 499, 500, 501, 3, -1, - 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 519, -1, 22, 23, 24, - 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, - -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, - -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, - -1, -1, 67, 68, 69, 70, 71, 72, 73, -1, - 75, 76, 77, 78, 79, -1, -1, -1, 83, 84, - 85, 86, 87, 88, -1, 90, 91, 92, -1, 94, - 95, 96, 97, 98, 99, -1, -1, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, - 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, - 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, - 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, -1, 161, -1, 163, 164, - 165, 166, -1, 168, -1, 170, -1, -1, -1, 174, - 175, 176, -1, 178, -1, 180, -1, 182, 183, 184, - 185, -1, 187, 188, 189, 190, 191, 192, 193, -1, - 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, - 205, 206, -1, 208, -1, 210, 211, 212, 213, 214, - 215, 216, 217, -1, 219, -1, 221, -1, -1, 224, - -1, 226, 227, 228, 229, 230, 231, -1, -1, 234, - -1, 236, -1, -1, 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, -1, 270, 271, 272, 273, 274, - -1, 276, 277, -1, 279, -1, 281, 282, 283, 284, - 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, - -1, -1, 297, 298, 299, -1, 301, -1, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - -1, -1, -1, -1, 319, 320, 321, -1, 323, 324, - 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, - 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, - 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, -1, 362, 363, -1, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, - 385, 386, 387, 388, 389, 390, 391, 392, -1, -1, - 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, - -1, -1, 417, 418, -1, 420, -1, 422, 423, 424, - 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, - 435, 436, 437, -1, 439, 440, 441, 442, 443, 444, - 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, - 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, - 465, -1, 467, -1, 469, 470, 471, 472, 473, 474, - 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 499, 500, 501, 3, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 518, 519, -1, 22, 23, 24, 25, - 26, 27, 28, 29, -1, 31, 32, 33, 34, 35, - -1, 37, -1, -1, -1, -1, 42, 43, 44, -1, + -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, + 31, 32, 33, -1, -1, -1, -1, -1, 39, -1, + -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, + 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, -1, 120, + 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, + 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, + 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, + 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, + -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, -1, -1, 234, 235, 236, 237, -1, 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, -1, 288, 289, -1, + -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, + 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, + 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, 463, 464, 465, -1, 467, 468, 469, 470, + 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + 501, 502, -1, -1, -1, -1, -1, -1, 509, 510, + 511, -1, -1, -1, -1, 516, -1, 518, -1, -1, + -1, -1, -1, 524, 525, 526, 527, 3, 4, 5, + 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, + -1, -1, -1, 39, -1, -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, - -1, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 56, 57, -1, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, - 126, 127, 128, 129, 130, 131, -1, -1, 134, 135, + -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, -1, 161, -1, 163, 164, 165, - 166, -1, 168, -1, 170, 171, 172, 173, 174, 175, + 156, 157, 158, 159, 160, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, @@ -15084,85 +14398,195 @@ static const yytype_int16 yycheck[] = 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, -1, - 276, 277, 278, 279, -1, 281, 282, 283, 284, 285, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, -1, 319, 320, 321, 322, 323, 324, 325, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, 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, + 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - -1, 417, 418, 419, 420, 421, 422, 423, 424, 425, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, - 436, 437, -1, 439, 440, 441, 442, 443, 444, 445, - 446, -1, -1, 449, 450, 451, 452, 453, 454, 455, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, 467, 468, 469, 470, 471, 472, 473, 474, 475, - -1, -1, 478, -1, 480, 481, 482, 483, 484, 485, + -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, - 496, 497, 498, 499, 500, 501, -1, 3, 504, 5, + 496, 497, 498, 499, 500, 501, -1, -1, -1, -1, + -1, -1, -1, 509, 510, -1, -1, -1, -1, -1, + 516, -1, 518, -1, -1, -1, -1, -1, 524, 525, + 526, 527, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 518, -1, -1, -1, 22, 23, 24, 25, + -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, + 31, 32, 33, -1, -1, -1, -1, -1, 39, -1, + -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, + 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, -1, 120, + 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, + 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, + 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, + 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, + -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, -1, -1, 224, 225, 226, 227, 228, 229, 230, + 231, -1, -1, 234, 235, 236, 237, -1, 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, -1, 276, 277, -1, 279, 280, + 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, + -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, + 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, + 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, 463, 464, 465, -1, 467, 468, 469, 470, + 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + 501, 502, -1, -1, -1, -1, -1, -1, 509, 510, + 511, -1, -1, -1, -1, 516, -1, 518, -1, -1, + -1, -1, -1, 524, 525, 526, 527, 3, 4, 5, + 6, 7, -1, 9, 10, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, - -1, -1, -1, -1, -1, -1, 42, 43, 44, -1, + -1, -1, -1, 39, -1, -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, + 56, 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, - 126, 127, 128, 129, 130, 131, -1, -1, 134, 135, + -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, -1, 161, -1, 163, 164, 165, - 166, -1, 168, -1, 170, 171, 172, 173, 174, 175, + 156, 157, 158, 159, 160, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, 231, 232, -1, 234, 235, + 226, 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, 237, -1, 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, -1, - 276, 277, 278, 279, -1, 281, 282, 283, 284, 285, - 286, -1, 288, 289, -1, 291, 292, 293, 294, -1, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, -1, 319, 320, 321, 322, 323, 324, 325, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, - 376, 377, 378, 379, 380, 381, 382, -1, 384, 385, - 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, - -1, 417, 418, 419, 420, 421, 422, 423, 424, 425, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, - 436, 437, -1, 439, 440, 441, 442, 443, 444, 445, - 446, -1, -1, 449, 450, 451, 452, 453, 454, 455, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, 467, 468, 469, 470, 471, 472, 473, 474, 475, - -1, -1, 478, -1, 480, 481, 482, 483, 484, 485, + -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, - 496, 497, 498, 499, 500, 501, -1, 3, 504, 5, + 496, 497, 498, 499, 500, 501, -1, -1, -1, -1, + -1, -1, -1, 509, 510, -1, -1, -1, -1, -1, + 516, -1, 518, -1, -1, -1, -1, -1, 524, 525, + 526, 527, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 518, -1, -1, -1, 22, 23, 24, 25, + -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, + 31, 32, 33, -1, -1, -1, -1, -1, 39, -1, + -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, + 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, + 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, + 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, + 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, + 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, + -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, -1, 223, 224, 225, 226, 227, 228, 229, 230, + 231, -1, -1, 234, 235, 236, 237, -1, 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, -1, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, + -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, + 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, + 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, 463, 464, 465, -1, 467, 468, 469, 470, + 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + 501, -1, -1, -1, -1, -1, -1, -1, 509, 510, + -1, -1, -1, -1, -1, 516, -1, 518, -1, -1, + -1, -1, -1, 524, 525, 526, 527, 3, 4, 5, + 6, 7, -1, 9, 10, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, - -1, -1, -1, -1, -1, -1, 42, 43, 44, -1, + -1, -1, -1, 39, -1, -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, + 56, 57, -1, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, @@ -15172,20 +14596,20 @@ static const yytype_int16 yycheck[] = -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, -1, 161, -1, 163, 164, 165, + 156, 157, 158, 159, 160, 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, -1, 173, 174, 175, - 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, + 176, 177, 178, -1, 180, 181, 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, 231, 232, -1, 234, 235, + 226, 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, 237, -1, 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, -1, - 276, 277, 278, 279, -1, 281, 282, 283, 284, 285, - 286, -1, 288, 289, -1, 291, 292, 293, 294, -1, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, 322, 323, 324, 325, @@ -15200,716 +14624,328 @@ static const yytype_int16 yycheck[] = 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, - 436, 437, -1, 439, 440, 441, 442, 443, 444, 445, - 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, - 456, -1, 458, 459, 460, 461, 462, 463, 464, 465, - -1, 467, 468, 469, 470, 471, 472, 473, 474, 475, - -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, - 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, - 496, 497, 498, 499, 500, 501, 3, -1, 5, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 518, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - -1, -1, -1, -1, -1, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, -1, 66, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, -1, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, - 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - 237, -1, 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, -1, 276, - 277, 278, 279, -1, 281, 282, 283, 284, 285, 286, - -1, 288, 289, -1, 291, 292, 293, 294, -1, -1, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, -1, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, - 467, 468, 469, 470, 471, 472, 473, 474, 475, -1, - -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, 3, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 518, -1, -1, 22, 23, 24, 25, 26, 27, - 28, 29, -1, 31, 32, 33, -1, -1, -1, -1, - -1, -1, -1, -1, 42, 43, 44, -1, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - -1, 59, 60, 61, 62, 63, 64, -1, 66, 67, - 68, 69, 70, 71, 72, 73, -1, 75, 76, 77, - 78, 79, -1, 81, -1, 83, 84, 85, 86, 87, - 88, 89, 90, 91, 92, -1, 94, 95, 96, 97, - 98, 99, -1, 101, 102, 103, 104, 105, 106, 107, - 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, - 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, - 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, - 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, - 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, -1, 161, -1, 163, 164, 165, 166, -1, - 168, -1, 170, 171, -1, 173, 174, 175, 176, 177, - 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 198, -1, 200, 201, 202, 203, 204, 205, 206, -1, - 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, - -1, 219, -1, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, -1, -1, 234, 235, 236, 237, - -1, 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, -1, 276, 277, - 278, 279, -1, 281, 282, 283, 284, 285, 286, -1, - 288, 289, -1, -1, 292, 293, 294, -1, -1, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, - -1, 319, 320, 321, 322, 323, 324, 325, 326, 327, - 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, - 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, -1, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, 379, 380, 381, -1, -1, 384, 385, 386, 387, - 388, 389, 390, 391, 392, -1, 394, 395, 396, 397, - 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, 412, 413, 414, -1, -1, 417, - 418, -1, 420, 421, 422, 423, 424, 425, 426, -1, - 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, - -1, 439, 440, 441, 442, 443, 444, 445, 446, -1, - -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, - 458, 459, 460, 461, 462, 463, 464, 465, -1, 467, - 468, 469, 470, 471, 472, 473, 474, 475, -1, -1, - 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 498, 499, 500, 501, 3, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 518, -1, -1, 22, 23, 24, 25, 26, 27, 28, - 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, - -1, -1, -1, 42, 43, 44, -1, 46, 47, 48, - 49, 50, 51, 52, 53, 54, 55, 56, 57, -1, - 59, 60, 61, 62, 63, 64, -1, 66, 67, 68, - 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, - 79, -1, 81, -1, 83, 84, 85, 86, 87, 88, - 89, 90, 91, 92, -1, 94, 95, 96, 97, 98, - 99, -1, 101, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, - -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, - 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, - -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, - 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, -1, 161, -1, 163, 164, 165, 166, -1, 168, - -1, 170, 171, -1, 173, 174, 175, 176, 177, 178, - -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, - 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, - -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, - 209, 210, 211, 212, 213, 214, 215, 216, 217, -1, - 219, -1, 221, 222, 223, 224, 225, 226, 227, 228, - 229, 230, 231, -1, -1, 234, 235, 236, 237, -1, - 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, -1, 276, 277, 278, - 279, -1, 281, 282, 283, 284, 285, 286, -1, 288, - 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, - 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, - 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, - 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, - 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, - 379, 380, 381, -1, -1, 384, 385, 386, 387, 388, - 389, 390, 391, 392, -1, 394, 395, 396, 397, 398, - -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, - -1, 420, 421, 422, 423, 424, 425, 426, -1, 428, - 429, 430, -1, -1, 433, 434, 435, 436, 437, -1, - 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, - 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, - 459, 460, 461, 462, 463, 464, 465, -1, 467, 468, - 469, 470, 471, 472, 473, 474, 475, -1, -1, 478, - -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, - 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, - 499, 500, 501, 3, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 518, - -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, - -1, 31, 32, 33, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, - 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, - 60, 61, 62, 63, 64, -1, -1, 67, 68, 69, - 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, - -1, -1, -1, 83, 84, 85, 86, 87, 88, -1, - 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, - -1, -1, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, - 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, - 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, - 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - -1, 161, -1, 163, 164, 165, 166, -1, 168, -1, - 170, -1, 172, -1, 174, 175, 176, -1, 178, -1, - 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, - 190, 191, 192, 193, -1, 195, 196, 197, 198, -1, - 200, 201, 202, 203, 204, 205, 206, -1, 208, -1, - 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, - -1, 221, -1, -1, 224, -1, 226, 227, 228, 229, - 230, 231, -1, -1, 234, -1, 236, -1, -1, 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, -1, - 270, 271, 272, 273, 274, -1, 276, 277, -1, 279, - -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, - -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, - -1, 301, -1, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, -1, 319, - 320, 321, -1, 323, 324, 325, 326, 327, 328, -1, - 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, - 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, - 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, -1, 362, 363, -1, 365, 366, 367, 368, 369, - 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, - 380, 381, 382, -1, 384, 385, 386, 387, 388, 389, - 390, 391, 392, 393, -1, 395, 396, 397, 398, -1, - 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, - 410, 411, 412, 413, 414, 415, -1, 417, 418, 419, - 420, -1, 422, 423, 424, 425, 426, -1, 428, 429, - 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, - 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, - 450, 451, 452, 453, 454, 455, 456, -1, 458, 459, - 460, 461, 462, 463, 464, 465, -1, 467, -1, 469, - 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, - 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, - 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, - 500, 501, -1, 3, 504, 5, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 518, -1, - -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, - 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, - 60, 61, 62, 63, 64, -1, -1, 67, 68, 69, - 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, - -1, -1, -1, 83, 84, 85, 86, 87, 88, -1, - 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, - -1, -1, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, - 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, - 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, - 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - -1, 161, -1, 163, 164, 165, 166, -1, 168, -1, - 170, -1, 172, -1, 174, 175, 176, -1, 178, -1, - 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, - 190, 191, 192, 193, -1, 195, 196, 197, 198, -1, - 200, 201, 202, 203, 204, 205, 206, -1, 208, -1, - 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, - -1, 221, -1, -1, 224, -1, 226, 227, 228, 229, - 230, 231, -1, -1, 234, -1, 236, -1, -1, 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, -1, - 270, 271, 272, 273, 274, -1, 276, 277, -1, 279, - -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, - -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, - -1, 301, -1, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, -1, 319, - 320, 321, -1, 323, 324, 325, 326, 327, 328, -1, - 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, - 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, - 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, -1, 362, 363, -1, 365, 366, 367, 368, 369, - 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, - 380, 381, 382, -1, 384, 385, 386, 387, 388, 389, - 390, 391, 392, -1, -1, 395, 396, 397, 398, -1, - 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, - 410, 411, 412, 413, 414, -1, -1, 417, 418, 419, - 420, -1, 422, 423, 424, 425, 426, -1, 428, 429, - 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, - 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, - 450, 451, 452, 453, 454, 455, 456, -1, 458, 459, - 460, 461, 462, 463, 464, 465, -1, 467, -1, 469, - 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, - 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, - 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, - 500, 501, -1, 3, 504, 5, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 518, -1, - -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, - -1, 31, 32, 33, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, - 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, - 60, 61, 62, 63, 64, -1, -1, 67, 68, 69, - 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, - -1, -1, -1, 83, 84, 85, 86, 87, 88, -1, - 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, - -1, -1, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, - 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, - 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, - 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - -1, 161, -1, 163, 164, 165, 166, -1, 168, -1, - 170, -1, 172, -1, 174, 175, 176, -1, 178, -1, - 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, - 190, 191, 192, 193, -1, 195, 196, 197, 198, -1, - 200, 201, 202, 203, 204, 205, 206, -1, 208, -1, - 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, - -1, 221, -1, -1, 224, -1, 226, 227, 228, 229, - 230, 231, -1, -1, 234, -1, 236, -1, -1, 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, -1, - 270, 271, 272, 273, 274, -1, 276, 277, -1, 279, - -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, - -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, - -1, 301, -1, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, -1, 319, - 320, 321, -1, 323, 324, 325, 326, 327, 328, -1, - 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, - 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, - 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, -1, 362, 363, -1, 365, 366, 367, 368, 369, - 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, - 380, 381, 382, -1, 384, 385, 386, 387, 388, 389, - 390, 391, 392, -1, -1, 395, 396, 397, 398, -1, - 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, - 410, 411, 412, 413, 414, -1, -1, 417, 418, 419, - 420, -1, 422, 423, 424, 425, 426, -1, 428, 429, - 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, - 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, - 450, 451, 452, 453, 454, 455, 456, -1, 458, 459, - 460, 461, 462, 463, 464, 465, -1, 467, -1, 469, - 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, - 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, - 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, - 500, 501, -1, 3, 504, 5, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 518, -1, - -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, - -1, 31, 32, 33, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, - 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, - 60, 61, 62, 63, 64, -1, -1, 67, 68, 69, - 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, - -1, -1, -1, 83, 84, 85, 86, 87, 88, -1, - 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, - -1, -1, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, - 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, - 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, - 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - -1, 161, -1, 163, 164, 165, 166, -1, 168, -1, - 170, -1, -1, -1, 174, 175, 176, -1, 178, -1, - 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, - 190, 191, 192, 193, -1, 195, 196, 197, 198, -1, - 200, 201, 202, 203, 204, 205, 206, -1, 208, -1, - 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, - -1, 221, -1, -1, 224, -1, 226, 227, 228, 229, - 230, 231, -1, -1, 234, -1, 236, -1, -1, 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, -1, - 270, 271, 272, 273, 274, -1, 276, 277, -1, 279, - -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, - -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, - -1, 301, -1, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, - 320, 321, -1, 323, 324, 325, 326, 327, 328, -1, - 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, - 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, - 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, -1, 362, 363, -1, 365, 366, 367, 368, 369, - 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, - 380, 381, -1, -1, 384, 385, 386, 387, 388, 389, - 390, 391, 392, -1, -1, 395, 396, 397, 398, -1, - 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, - 410, 411, 412, 413, 414, -1, -1, 417, 418, -1, - 420, -1, 422, 423, 424, 425, 426, -1, 428, 429, - 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, - 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, - 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, - 460, 461, 462, 463, 464, 465, -1, 467, -1, 469, - 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, - -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, - 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, - 500, 501, 3, -1, 5, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 518, -1, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, 465, + -1, 467, 468, 469, 470, 471, 472, 473, 474, 475, + -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 501, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 516, -1, 518, -1, -1, -1, -1, -1, 524, 525, + 526, 527, 3, 4, 5, 6, 7, -1, 9, 10, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, - 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, - 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, - 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, + 31, 32, 33, -1, -1, -1, -1, -1, 39, -1, + -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, - -1, -1, 83, 84, 85, 86, 87, 88, -1, 90, + 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, - -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, -1, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, - -1, -1, -1, 174, 175, 176, -1, 178, -1, 180, + 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, - 191, 192, 193, -1, 195, 196, 197, 198, -1, 200, - 201, 202, 203, 204, 205, 206, -1, 208, -1, 210, - 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, - 221, -1, -1, 224, -1, 226, 227, 228, 229, 230, - 231, -1, -1, 234, -1, 236, -1, -1, 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, -1, 270, - 271, 272, 273, 274, -1, 276, 277, -1, 279, -1, - 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, - -1, 292, 293, 294, -1, -1, 297, 298, 299, -1, - 301, -1, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, - 321, -1, 323, 324, 325, 326, 327, 328, -1, 330, - 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - -1, 362, 363, -1, 365, 366, 367, 368, 369, 370, - 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, - 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, - 391, 392, -1, -1, 395, 396, 397, 398, -1, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, - -1, 422, 423, 424, 425, 426, -1, 428, 429, 430, - -1, -1, 433, 434, 435, 436, 437, -1, 439, 440, - 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, - 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, - 461, 462, 463, 464, 465, -1, 467, -1, 469, 470, - 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, - 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, - 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, - 501, 3, -1, 5, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 518, -1, -1, - 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, - 32, 33, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, - 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, - 62, 63, 64, -1, -1, 67, 68, 69, 70, 71, - 72, 73, -1, 75, 76, 77, 78, 79, -1, -1, - -1, 83, 84, 85, 86, 87, 88, -1, 90, 91, - 92, -1, 94, 95, 96, 97, 98, 99, -1, -1, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, - 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, - -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, - 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, -1, 161, - -1, 163, 164, 165, 166, -1, 168, -1, 170, -1, - -1, -1, 174, 175, 176, -1, 178, -1, 180, -1, - 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, - 192, 193, -1, 195, 196, 197, 198, -1, 200, 201, - 202, 203, 204, 205, 206, -1, 208, -1, 210, 211, - 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, - -1, -1, 224, -1, 226, 227, 228, 229, 230, 231, - -1, -1, 234, -1, 236, -1, -1, 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, -1, 270, 271, - 272, 273, 274, -1, 276, 277, -1, 279, -1, 281, - 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, - 292, 293, 294, -1, -1, 297, 298, 299, -1, 301, - -1, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, - -1, 323, 324, 325, 326, 327, 328, -1, 330, 331, - 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, - 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, - 362, 363, -1, 365, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, - 392, -1, -1, 395, 396, 397, 398, -1, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, -1, -1, 417, 418, -1, 420, -1, - 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, - -1, 433, 434, 435, 436, 437, -1, 439, 440, 441, - 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, - -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, - 462, 463, 464, 465, -1, 467, -1, 469, 470, 471, - 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, - 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, - 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 518, -1, -1, 22, - 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, - 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, - 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, - 63, 64, -1, -1, 67, 68, 69, 70, 71, 72, - 73, -1, 75, 76, 77, 78, 79, -1, -1, -1, - 83, 84, 85, 86, 87, 88, -1, 90, 91, 92, - -1, 94, 95, 96, 97, 98, 99, -1, -1, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, - 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, - -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, - -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, -1, 161, -1, - 163, 164, 165, 166, -1, 168, -1, 170, -1, -1, - -1, 174, 175, 176, -1, 178, -1, 180, -1, 182, - 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, - 193, -1, 195, 196, 197, 198, -1, 200, 201, 202, - 203, 204, 205, 206, -1, 208, -1, 210, 211, 212, - 213, 214, 215, 216, 217, -1, 219, -1, 221, -1, - -1, 224, -1, 226, 227, 228, 229, 230, 231, -1, - -1, 234, -1, 236, -1, -1, 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, -1, 270, 271, 272, - 273, 274, -1, 276, 277, -1, 279, -1, 281, 282, - 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, - 293, 294, -1, -1, 297, 298, 299, -1, 301, -1, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, -1, -1, -1, -1, 319, 320, 321, -1, - 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, - 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, - 363, -1, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, - -1, 384, 385, 386, 387, 388, 389, 390, 391, 392, - -1, -1, 395, 396, 397, 398, -1, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, -1, -1, 417, 418, -1, 420, -1, 422, - 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, - 433, 434, 435, 436, 437, -1, 439, 440, 441, 442, - 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, - 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, - 463, 464, 465, -1, 467, -1, 469, 470, 471, 472, - 473, 474, 475, -1, -1, 478, -1, -1, 481, 482, - 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 498, 499, 500, 501, 3, - -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 518, -1, -1, 22, 23, - 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, - 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, - 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, - 64, -1, -1, 67, 68, 69, 70, 71, 72, 73, - -1, 75, 76, 77, 78, 79, -1, -1, -1, 83, - 84, 85, 86, 87, 88, -1, 90, 91, 92, -1, - 94, 95, 96, 97, 98, 99, -1, -1, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, - 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, - 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, - 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, -1, 161, -1, 163, - 164, 165, 166, -1, 168, -1, 170, -1, -1, -1, - 174, 175, 176, -1, 178, -1, 180, -1, 182, 183, - 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, - -1, 195, 196, 197, 198, -1, 200, 201, 202, 203, - 204, 205, 206, -1, 208, -1, 210, 211, 212, 213, - 214, 215, 216, 217, -1, 219, -1, 221, -1, -1, - 224, -1, 226, 227, 228, 229, 230, 231, -1, -1, - 234, -1, 236, -1, -1, 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, -1, 270, 271, 272, 273, - 274, -1, 276, 277, -1, 279, -1, 281, 282, 283, - 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, - 294, -1, -1, 297, 298, 299, -1, 301, -1, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, -1, -1, -1, -1, 319, 320, 321, -1, 323, - 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, - 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, - 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, - -1, 365, 366, 367, 368, 369, 370, 371, 372, 373, - 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, - 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, - -1, 395, 396, 397, 398, -1, 400, 401, 402, 403, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, -1, -1, 417, 418, -1, 420, -1, 422, 423, - 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, - 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, - 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, - 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, - 464, 465, -1, 467, -1, 469, 470, 471, 472, 473, - 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, - 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, - 494, 495, 496, 497, 498, 499, 500, 501, 3, -1, - 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 518, -1, -1, 22, 23, 24, - 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, - -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, - -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, - -1, -1, 67, 68, 69, 70, 71, 72, 73, -1, - 75, 76, 77, 78, 79, -1, -1, -1, 83, 84, - 85, 86, 87, 88, -1, 90, 91, 92, -1, 94, - 95, 96, 97, 98, 99, -1, -1, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, - 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, - 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, - 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, -1, 161, -1, 163, 164, - 165, 166, -1, 168, -1, 170, -1, -1, -1, 174, - 175, 176, -1, 178, -1, 180, -1, 182, 183, 184, - 185, -1, 187, 188, 189, 190, 191, 192, 193, -1, - 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, - 205, 206, -1, 208, -1, 210, 211, 212, 213, 214, - 215, 216, 217, -1, 219, -1, 221, -1, -1, 224, - -1, 226, 227, 228, 229, 230, 231, -1, -1, 234, - -1, 236, -1, -1, 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, -1, 270, 271, 272, 273, 274, - -1, 276, 277, -1, 279, -1, 281, 282, 283, 284, - 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, - -1, -1, 297, 298, 299, -1, 301, -1, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - -1, -1, -1, -1, 319, 320, 321, -1, 323, 324, - 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, - 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, - 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, -1, 362, 363, -1, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, - 385, 386, 387, 388, 389, 390, 391, 392, -1, -1, - 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, - -1, -1, 417, 418, -1, 420, -1, 422, 423, 424, - 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, - 435, 436, 437, -1, 439, 440, 441, 442, 443, 444, - 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, - 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, - 465, -1, 467, -1, 469, 470, 471, 472, 473, 474, - 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 499, 500, 501, 3, -1, 5, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 518, -1, -1, 22, 23, 24, 25, + 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, -1, -1, 234, 235, 236, 237, -1, 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, -1, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, + -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, + 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, + 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, 463, 464, 465, -1, 467, 468, 469, 470, + 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + 501, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 516, -1, 518, -1, -1, + -1, -1, -1, 524, 525, 526, 527, 3, 4, 5, + 6, 7, -1, 9, 10, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, - 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, - 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, - -1, 67, 68, 69, 70, 71, 72, 73, -1, 75, - 76, 77, 78, 79, -1, -1, -1, 83, 84, 85, - 86, 87, 88, -1, 90, 91, 92, -1, 94, 95, - 96, 97, 98, 99, -1, -1, 102, 103, 104, 105, + -1, -1, -1, 39, -1, -1, 42, 43, 44, -1, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, -1, 59, 60, 61, 62, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, 81, -1, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, -1, 161, -1, 163, 164, 165, - 166, -1, 168, -1, 170, -1, -1, -1, 174, 175, - 176, -1, 178, -1, 180, -1, 182, 183, 184, 185, - -1, 187, 188, 189, 190, 191, 192, 193, -1, 195, + 156, 157, 158, 159, 160, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, 171, -1, 173, 174, 175, + 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, - 206, -1, 208, -1, 210, 211, 212, 213, 214, 215, - 216, 217, -1, 219, -1, 221, -1, -1, 224, -1, - 226, 227, 228, 229, 230, 231, -1, -1, 234, -1, - 236, -1, -1, 239, 240, 241, 242, 243, 244, 245, + 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, -1, -1, 234, 235, + 236, 237, -1, 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, -1, 270, 271, 272, 273, 274, -1, - 276, 277, -1, 279, -1, 281, 282, 283, 284, 285, + 266, 267, 268, 269, 270, 271, 272, 273, 274, -1, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, - -1, 297, 298, 299, -1, 301, -1, 303, 304, 305, + -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, - -1, -1, -1, 319, 320, 321, -1, 323, 324, 325, + -1, -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, -1, 362, 363, -1, 365, + 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, - 386, 387, 388, 389, 390, 391, 392, -1, -1, 395, + 386, 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, - -1, 417, 418, -1, 420, -1, 422, 423, 424, 425, + -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, - 436, 437, -1, 439, 440, 441, 442, 443, 444, 445, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, 465, - -1, 467, -1, 469, 470, 471, 472, 473, 474, 475, + -1, 467, 468, 469, 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, - 496, 497, 498, 499, 500, 501, 3, -1, 5, -1, + 496, 497, 498, 499, 500, 501, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 518, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, - 47, 48, -1, 50, 51, 52, 53, 54, -1, 56, - 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, -1, -1, 83, 84, 85, 86, - 87, 88, -1, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, -1, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, -1, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, -1, -1, -1, 174, 175, 176, - -1, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, -1, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, -1, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, -1, -1, 224, -1, 226, - 227, 228, 229, 230, 231, -1, -1, 234, -1, 236, - -1, -1, 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, -1, 270, 271, 272, 273, 274, -1, 276, - 277, -1, 279, -1, 281, 282, 283, 284, 285, 286, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, -1, 301, -1, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, -1, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, -1, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, -1, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, -1, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, -1, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, - 467, -1, 469, 470, 471, 472, 473, 474, 475, -1, - -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, 3, -1, -1, -1, -1, + 516, -1, 518, -1, -1, -1, -1, -1, 524, 525, + 526, 527, 3, 4, 5, 6, 7, 8, 9, 10, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, + 31, 32, 33, -1, -1, -1, -1, -1, 39, -1, + -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, + 51, 52, -1, 54, 55, 56, 57, -1, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, + 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, -1, 120, + 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, + 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, + 141, 142, -1, 144, -1, 146, -1, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, + 171, -1, 173, 174, 175, 176, -1, 178, -1, 180, + -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, + 191, 192, 193, -1, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, -1, -1, 224, 225, 226, 227, 228, 229, 230, + 231, -1, -1, 234, 235, 236, -1, -1, 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, -1, 276, 277, -1, 279, 280, + 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, + -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, + 391, 392, -1, -1, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, + 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, 463, 464, 465, -1, 467, 468, 469, 470, + 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + 501, -1, -1, -1, -1, -1, -1, -1, 509, 510, + 511, -1, 3, 4, 5, 516, -1, 518, 9, -1, + -1, -1, -1, 524, 525, 526, 527, -1, -1, -1, + -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, + 31, 32, 33, -1, -1, -1, 37, -1, -1, -1, + -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, + 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, + 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, + 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, + 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, + 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, + 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, + 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, + -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, -1, -1, 234, 235, 236, 237, -1, 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, -1, 276, 277, 278, 279, -1, + 281, 282, 283, 284, 285, 286, -1, 288, 289, 290, + -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, -1, 383, 384, 385, 386, 387, 388, 389, 390, + 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, + 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, 463, 464, 465, -1, 467, 468, 469, 470, + 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + 501, -1, -1, -1, -1, -1, -1, -1, 509, 510, + 511, 3, -1, -1, -1, 516, -1, 518, 10, -1, + -1, -1, -1, -1, -1, -1, 527, -1, -1, -1, + 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, + 32, 33, -1, -1, -1, -1, -1, 39, -1, -1, + 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, + -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, + 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, + -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, + 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, -1, 161, + -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, + -1, 173, 174, 175, 176, 177, 178, -1, 180, -1, + 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, + 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + -1, -1, 234, 235, 236, 237, -1, 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, -1, 276, 277, 278, 279, -1, 281, + 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, + 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, + 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, + -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, + 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, -1, -1, 417, 418, -1, 420, 421, + 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, + -1, 433, 434, 435, 436, 437, -1, 439, 440, 441, + 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, + -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, + 462, 463, 464, 465, -1, 467, 468, 469, 470, 471, + 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 518, -1, -1, 22, 23, 24, 25, 26, 27, + -1, 3, 4, -1, 516, -1, 518, 9, 10, -1, + -1, -1, 524, 525, 526, 527, -1, -1, -1, -1, + 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, + 32, 33, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, + 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, + 62, 63, 64, -1, -1, 67, 68, 69, 70, 71, + 72, 73, -1, 75, 76, 77, 78, 79, -1, -1, + -1, 83, 84, 85, 86, 87, 88, -1, 90, 91, + 92, -1, 94, 95, 96, 97, 98, 99, -1, -1, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, + 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, + -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, + 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, -1, 161, + -1, 163, 164, 165, 166, -1, 168, -1, 170, -1, + -1, -1, 174, 175, 176, -1, 178, -1, 180, -1, + 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, + 192, 193, -1, 195, 196, 197, 198, -1, 200, 201, + 202, 203, 204, 205, 206, -1, 208, -1, 210, 211, + 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, + -1, -1, 224, -1, 226, 227, 228, 229, 230, 231, + -1, -1, 234, -1, 236, -1, -1, 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, -1, 270, 271, + 272, 273, 274, -1, 276, 277, -1, 279, -1, 281, + 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, + 292, 293, 294, -1, -1, 297, 298, 299, -1, 301, + -1, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, + -1, 323, 324, 325, 326, 327, 328, -1, 330, 331, + 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, + 362, 363, -1, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, + -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, + 392, -1, -1, 395, 396, 397, 398, -1, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, -1, -1, 417, 418, -1, 420, -1, + 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, + -1, 433, 434, 435, 436, 437, -1, 439, 440, 441, + 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, + -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, + 462, 463, 464, 465, -1, 467, -1, 469, 470, 471, + 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, + -1, -1, -1, -1, -1, 3, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 524, 525, 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 43, 44, -1, 46, 47, + -1, -1, 40, -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, 77, @@ -15919,22 +14955,22 @@ static const yytype_int16 yycheck[] = 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, - 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, + 138, -1, 140, 141, 142, -1, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, -1, 161, -1, 163, 164, 165, 166, -1, + 158, 159, -1, 161, 162, 163, 164, 165, 166, 167, 168, -1, 170, -1, -1, -1, 174, 175, 176, -1, 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, -1, 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, - -1, 219, -1, 221, -1, -1, 224, -1, 226, 227, + 218, 219, -1, 221, -1, -1, 224, -1, 226, 227, 228, 229, 230, 231, -1, -1, 234, -1, 236, -1, - -1, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 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, -1, 270, 271, 272, 273, 274, -1, 276, 277, - -1, 279, -1, 281, 282, 283, 284, 285, 286, -1, - 288, 289, -1, -1, 292, 293, 294, -1, -1, 297, + -1, 279, -1, 281, 282, 283, 284, 285, 286, 287, + 288, 289, -1, -1, 292, 293, 294, -1, 296, 297, 298, 299, -1, 301, -1, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, -1, 323, 324, 325, 326, 327, @@ -15949,115 +14985,15 @@ static const yytype_int16 yycheck[] = 408, 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, -1, 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, - -1, 439, 440, 441, 442, 443, 444, 445, 446, -1, + -1, 439, 440, 441, 442, 443, 444, 445, 446, 447, -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, 467, -1, 469, 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 498, 499, 500, 501, 3, -1, -1, -1, -1, -1, + 498, 499, 500, 501, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 518, -1, -1, 22, 23, 24, 25, 26, 27, 28, - 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 43, 44, -1, 46, 47, 48, - -1, 50, 51, 52, 53, 54, -1, 56, 57, -1, - 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, - 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, - 79, -1, -1, -1, 83, 84, 85, 86, 87, 88, - -1, 90, 91, 92, -1, 94, 95, 96, 97, 98, - 99, -1, -1, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, - -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, - 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, - -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, - 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, -1, 161, -1, 163, 164, 165, 166, -1, 168, - -1, 170, -1, -1, -1, 174, 175, 176, -1, 178, - -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, - 189, 190, 191, 192, 193, -1, 195, 196, 197, 198, - -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, - -1, 210, 211, 212, 213, 214, 215, 216, 217, -1, - 219, -1, 221, -1, -1, 224, -1, 226, 227, 228, - 229, 230, 231, -1, -1, 234, -1, 236, -1, -1, - 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, - -1, 270, 271, 272, 273, 274, -1, 276, 277, -1, - 279, -1, 281, 282, 283, 284, 285, 286, -1, 288, - 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, - 299, -1, 301, -1, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, - 319, 320, 321, -1, 323, 324, 325, 326, 327, 328, - -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, - 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, - 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, -1, 362, 363, -1, 365, 366, 367, 368, - 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, - 379, 380, 381, -1, -1, 384, 385, 386, 387, 388, - 389, 390, 391, 392, -1, -1, 395, 396, 397, 398, - -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, - -1, 420, -1, 422, 423, 424, 425, 426, -1, 428, - 429, 430, -1, -1, 433, 434, 435, 436, 437, -1, - 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, - 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, - 459, 460, 461, 462, 463, 464, 465, -1, 467, -1, - 469, 470, 471, 472, 473, 474, 475, -1, -1, 478, - -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, - 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, - 499, 500, 501, -1, 3, 4, 5, -1, -1, 8, - 9, -1, -1, -1, -1, -1, 15, 16, -1, 518, - 19, 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, -1, 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, - -1, 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, -1, 153, 154, 155, 156, 157, 158, - -1, 160, 161, 162, 163, 164, 165, 166, 167, 168, - 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, - 179, 180, 181, -1, -1, 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, -1, 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, -1, 282, 283, 284, 285, 286, 287, 288, - 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, - -1, 300, 301, 302, -1, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, -1, 322, 323, 324, -1, 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, -1, 415, 416, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, - 429, 430, 431, 432, 433, 434, -1, 436, -1, 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, -1, 464, 465, 466, 467, 468, - 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, - 479, 480, 481, 482, 483, 484, 485, 486, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 498, - 499, 500, 501, -1, 3, -1, 505, 506, 507, 8, - 509, 510, 511, 512, 513, 514, 15, 16, -1, -1, - 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + -1, 519, -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, 56, 57, -1, @@ -16105,271 +15041,308 @@ static const yytype_int16 yycheck[] = 469, 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, - 499, 500, 501, -1, -1, -1, 505, 506, 507, -1, - 509, 510, 511, 512, 513, 514, 8, -1, -1, 11, - -1, -1, -1, 15, 16, 17, 18, 19, 20, 21, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 36, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 46, 8, -1, -1, 11, -1, - -1, 53, 15, 16, 17, 18, 19, 20, 21, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 36, -1, -1, -1, -1, 80, -1, - -1, -1, -1, 46, 8, -1, -1, 11, -1, -1, - 53, 15, 16, 17, 18, 19, 20, 21, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 36, -1, -1, -1, -1, 80, -1, -1, - -1, -1, 46, -1, -1, -1, -1, -1, -1, 53, - -1, -1, 8, -1, -1, 11, -1, -1, -1, 15, - 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 80, -1, -1, -1, - 36, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 46, 8, -1, -1, 11, 177, -1, 53, 15, 16, - 17, 18, 19, 20, 21, -1, -1, -1, -1, -1, - -1, -1, 194, -1, -1, -1, -1, 199, -1, 36, - -1, -1, -1, -1, 80, -1, -1, -1, -1, 46, - -1, -1, -1, -1, 177, -1, 53, -1, -1, -1, - 222, 223, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 194, -1, -1, -1, 237, 199, -1, -1, -1, - -1, -1, -1, 80, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 177, -1, -1, -1, -1, -1, 222, - 223, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 194, -1, -1, 275, 237, 199, 278, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 292, -1, -1, 295, -1, -1, -1, -1, 222, 223, - -1, 177, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 275, 237, -1, 278, -1, -1, 194, -1, - -1, -1, -1, 199, -1, -1, -1, -1, -1, 292, - -1, -1, 295, -1, -1, -1, -1, -1, -1, -1, - 177, -1, -1, -1, -1, -1, 222, 223, -1, -1, - -1, 275, -1, -1, 278, -1, -1, 194, -1, -1, - -1, 237, 199, -1, -1, -1, -1, -1, 292, -1, - -1, 295, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 222, 223, -1, -1, -1, - -1, -1, 394, -1, -1, -1, -1, -1, -1, 275, - 237, -1, 278, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 292, -1, -1, 295, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 394, -1, -1, -1, -1, -1, -1, 275, -1, - -1, 278, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 292, -1, -1, 295, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 394, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 502, -1, -1, 505, 506, 507, -1, 509, 510, 511, - 512, 513, 514, -1, -1, -1, -1, 519, 394, -1, - -1, -1, -1, -1, 8, -1, -1, 11, -1, -1, - -1, 15, 16, 17, 18, 19, 20, 21, -1, 502, - -1, -1, 505, 506, 507, -1, 509, 510, 511, 512, - 513, 514, 36, -1, -1, -1, 519, 394, -1, -1, - -1, -1, 46, -1, -1, -1, -1, -1, -1, 53, - -1, -1, -1, -1, -1, -1, -1, -1, 502, -1, - -1, 505, 506, 507, -1, 509, 510, 511, 512, 513, - 514, -1, -1, -1, -1, 519, 80, -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, 19, 20, 21, -1, 502, -1, -1, 505, - 506, 507, -1, 509, 510, 511, 512, 513, 514, 36, - -1, -1, -1, 519, -1, -1, -1, -1, -1, 46, - 8, -1, -1, 11, -1, -1, 53, 15, 16, 17, - 18, 19, 20, 21, -1, 502, -1, -1, 505, 506, - 507, -1, 509, 510, 511, 512, 513, 514, 36, -1, - -1, -1, 519, 80, -1, -1, -1, -1, 46, 8, - -1, -1, 11, 177, -1, 53, 15, 16, 17, 18, - 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, - 194, -1, -1, -1, -1, 199, -1, 36, -1, -1, - -1, -1, 80, -1, -1, -1, -1, 46, -1, -1, - -1, -1, -1, -1, 53, -1, -1, -1, 222, 223, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 237, -1, -1, -1, -1, -1, -1, - -1, 80, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 8, -1, -1, 11, - 177, -1, -1, 15, 16, 17, 18, 19, 20, 21, - -1, 275, -1, -1, 278, -1, -1, 194, -1, -1, - -1, -1, 199, -1, 36, -1, -1, -1, 292, -1, - -1, 295, -1, -1, 46, -1, -1, -1, -1, 177, - -1, 53, -1, -1, -1, 222, 223, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 194, -1, -1, -1, - 237, 199, -1, -1, -1, -1, -1, -1, 80, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 177, -1, - -1, -1, -1, -1, 222, 223, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 194, -1, -1, 275, 237, - 199, 278, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 292, -1, -1, 295, -1, - -1, -1, -1, 222, 223, -1, -1, -1, -1, -1, - 394, -1, -1, -1, -1, -1, -1, 275, 237, -1, - 278, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 292, -1, -1, 295, -1, -1, - -1, -1, -1, -1, -1, 177, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 275, -1, -1, 278, - -1, -1, 194, -1, -1, -1, -1, 199, -1, -1, - -1, -1, -1, 292, -1, -1, 295, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 222, 223, -1, -1, -1, -1, -1, 394, -1, -1, - -1, -1, -1, -1, -1, 237, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 502, -1, - -1, 505, 506, 507, -1, 509, 510, 511, 512, 513, - 514, -1, -1, -1, -1, 519, 394, -1, -1, -1, - -1, -1, -1, 275, -1, -1, 278, -1, -1, -1, - -1, -1, -1, -1, 8, -1, -1, 11, -1, -1, - 292, 15, 16, 295, -1, 19, 20, 21, -1, -1, - -1, -1, -1, 8, -1, 394, 11, -1, -1, -1, - 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, - -1, -1, 46, -1, -1, -1, -1, -1, -1, 53, - -1, 36, -1, -1, -1, 502, -1, -1, 505, 506, - 507, 46, 509, 510, 511, 512, 513, 514, 53, -1, - -1, -1, 519, -1, -1, -1, 80, -1, -1, -1, - 8, -1, -1, 11, -1, -1, -1, 15, 16, 17, - 18, 19, 20, 21, 502, 80, -1, 505, 506, 507, - -1, 509, 510, 511, 512, 513, 514, -1, 36, -1, - -1, 519, 394, -1, -1, -1, -1, -1, 46, -1, - -1, -1, -1, -1, -1, 53, -1, -1, -1, -1, - -1, -1, -1, 502, -1, -1, 505, 506, 507, -1, - 509, 510, 511, 512, 513, 514, -1, -1, 517, -1, - -1, -1, 80, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 177, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 194, -1, 177, -1, -1, 199, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 194, - -1, -1, -1, -1, 199, -1, -1, -1, 222, 223, - 502, -1, -1, 505, 506, 507, -1, 509, 510, 511, - 512, 513, 514, 237, -1, 517, -1, 222, 223, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 177, - -1, -1, 237, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 194, -1, -1, -1, - -1, 199, -1, -1, 278, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 292, -1, - 275, -1, -1, 278, 222, 223, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 292, -1, 237, - 295, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 275, -1, -1, - 278, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 292, -1, -1, 295, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 394, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 394, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 394, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 502, -1, - -1, 505, 506, 507, -1, 509, 510, 511, 512, 513, - 514, -1, -1, -1, -1, -1, -1, 502, -1, -1, - 505, 506, 507, -1, 509, 510, 511, 512, 513, 514, - -1, -1, 517, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -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, 502, -1, -1, 505, 506, 507, - -1, 509, 510, 511, 512, 513, 514, -1, -1, 517, - 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, 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, + 499, 500, 501, 3, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 518, + 519, -1, 22, 23, 24, 25, 26, 27, 28, 29, + -1, 31, 32, 33, 34, 35, -1, 37, -1, -1, + -1, -1, 42, 43, 44, -1, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, + 60, 61, 62, 63, 64, -1, -1, 67, 68, 69, + 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, + -1, 81, -1, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, + -1, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, + 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, + 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, + 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + -1, 161, -1, 163, 164, 165, 166, -1, 168, -1, + 170, 171, 172, 173, 174, 175, 176, 177, 178, -1, + 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, -1, + 200, 201, 202, 203, 204, 205, 206, -1, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, + -1, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, -1, -1, 234, 235, 236, 237, -1, 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, -1, 276, 277, 278, 279, + -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, + -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, -1, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, -1, + 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, + 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, -1, 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, -1, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, -1, 417, 418, 419, + 420, 421, 422, 423, 424, 425, 426, -1, 428, 429, + 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, + 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, + 450, 451, 452, 453, 454, 455, 456, -1, 458, 459, + 460, 461, 462, 463, 464, 465, -1, 467, 468, 469, + 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, + 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, + 500, 501, -1, 3, 504, 5, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 518, -1, + -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, + -1, 31, 32, 33, -1, -1, -1, -1, -1, -1, + -1, -1, 42, 43, 44, -1, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, + 60, 61, 62, 63, 64, -1, 66, 67, 68, 69, + 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, + -1, 81, -1, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, + -1, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, + 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, + 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, + 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + -1, 161, -1, 163, 164, 165, 166, -1, 168, -1, + 170, 171, 172, 173, 174, 175, 176, 177, 178, -1, + 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, -1, + 200, 201, 202, 203, 204, 205, 206, -1, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, + -1, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, 232, -1, 234, 235, 236, 237, -1, 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, -1, 276, 277, 278, 279, + -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, + -1, 291, 292, 293, 294, -1, -1, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, -1, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, -1, + 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, + 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, + 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, + 380, 381, 382, -1, 384, 385, 386, 387, 388, 389, + 390, 391, 392, 393, 394, 395, 396, 397, 398, -1, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, -1, 417, 418, 419, + 420, 421, 422, 423, 424, 425, 426, -1, 428, 429, + 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, + 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, + 450, 451, 452, 453, 454, 455, 456, -1, 458, 459, + 460, 461, 462, 463, 464, 465, -1, 467, 468, 469, + 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, + 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, + 500, 501, -1, 3, 504, 5, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 518, -1, + -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, + -1, 31, 32, 33, -1, -1, -1, -1, -1, -1, + -1, -1, 42, 43, 44, -1, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, + 60, 61, 62, 63, 64, -1, 66, 67, 68, 69, + 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, + -1, 81, -1, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, + -1, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, + 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, + 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, + 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + -1, 161, -1, 163, 164, 165, 166, -1, 168, -1, + 170, 171, -1, 173, 174, 175, 176, 177, 178, -1, + 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, -1, + 200, 201, 202, 203, 204, 205, 206, -1, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, + -1, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, 232, -1, 234, 235, 236, 237, -1, 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, -1, 276, 277, 278, 279, + -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, + -1, 291, 292, 293, 294, -1, -1, 297, 298, 299, + 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, -1, + 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, + 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, + 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, + 380, 381, -1, -1, 384, 385, 386, 387, 388, 389, + 390, 391, 392, -1, 394, 395, 396, 397, 398, -1, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, -1, -1, 417, 418, -1, + 420, 421, 422, 423, 424, 425, 426, -1, 428, 429, + 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, + 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, + 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, + 460, 461, 462, 463, 464, 465, -1, 467, 468, 469, + 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, + -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, + 500, 501, 3, -1, 5, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 518, -1, + -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, + 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, + -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, + 61, 62, 63, 64, -1, 66, 67, 68, 69, 70, + 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, + 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, + 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, + 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, + 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, -1, + 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, + 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, + -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, -1, -1, 234, 235, 236, 237, -1, 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, -1, 276, 277, 278, 279, -1, + 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, + 291, 292, 293, 294, -1, -1, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, + 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, + 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, 435, 436, 437, -1, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, 463, 464, 465, -1, 467, 468, 469, 470, + 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + 501, 3, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 518, -1, -1, + 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, + 32, 33, -1, -1, -1, -1, -1, -1, -1, -1, + 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, + 62, 63, 64, -1, 66, 67, 68, 69, 70, 71, + 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, + -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, -1, 94, 95, 96, 97, 98, 99, -1, 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, + 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, + 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, + -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, + 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, -1, 161, + -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, + -1, 173, 174, 175, 176, 177, 178, -1, 180, -1, + 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, + 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, + -1, -1, 234, 235, 236, 237, -1, 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, + 272, 273, 274, -1, 276, 277, 278, 279, -1, 281, + 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, + 292, 293, 294, -1, -1, 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, + 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, + 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, 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, + -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, + 392, -1, 394, 395, 396, 397, 398, -1, 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, + 412, 413, 414, -1, -1, 417, 418, -1, 420, 421, + 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, + -1, 433, 434, 435, 436, 437, -1, 439, 440, 441, + 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, + -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, + 462, 463, 464, 465, -1, 467, 468, 469, 470, 471, + 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, - 3, -1, -1, -1, -1, -1, -1, -1, -1, 511, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, + 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 518, -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, - 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, - 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, - 63, 64, -1, -1, 67, 68, 69, 70, 71, 72, - 73, -1, 75, 76, 77, 78, 79, -1, -1, -1, - 83, 84, 85, 86, 87, 88, -1, 90, 91, 92, - -1, 94, 95, 96, 97, 98, 99, -1, -1, 102, + 33, -1, -1, -1, -1, -1, -1, -1, -1, 42, + 43, 44, -1, 46, 47, 48, 49, 50, 51, 52, + 53, 54, 55, 56, 57, -1, 59, 60, 61, 62, + 63, 64, -1, 66, 67, 68, 69, 70, 71, 72, + 73, -1, 75, 76, 77, 78, 79, -1, 81, -1, + 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, + -1, 94, 95, 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, -1, 161, -1, - 163, 164, 165, 166, -1, 168, -1, 170, -1, -1, - -1, 174, 175, 176, -1, 178, -1, 180, -1, 182, + 163, 164, 165, 166, -1, 168, -1, 170, 171, -1, + 173, 174, 175, 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, - 193, -1, 195, 196, 197, 198, -1, 200, 201, 202, - 203, 204, 205, 206, -1, 208, -1, 210, 211, 212, - 213, 214, 215, 216, 217, -1, 219, -1, 221, -1, - -1, 224, -1, 226, 227, 228, 229, 230, 231, -1, - -1, 234, -1, 236, -1, -1, 239, 240, 241, 242, + 193, 194, 195, 196, 197, 198, -1, 200, 201, 202, + 203, 204, 205, 206, -1, 208, 209, 210, 211, 212, + 213, 214, 215, 216, 217, -1, 219, -1, 221, 222, + 223, 224, 225, 226, 227, 228, 229, 230, 231, -1, + -1, 234, 235, 236, 237, -1, 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, -1, 270, 271, 272, - 273, 274, -1, 276, 277, -1, 279, -1, 281, 282, + 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, + 273, 274, -1, 276, 277, 278, 279, -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, - 293, 294, -1, -1, 297, 298, 299, -1, 301, -1, + 293, 294, -1, -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, -1, -1, -1, -1, 319, 320, 321, -1, + 313, 314, -1, -1, -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, - 363, -1, 365, 366, 367, 368, 369, 370, 371, 372, + 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, 392, - -1, -1, 395, 396, 397, 398, -1, 400, 401, 402, + -1, 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, -1, -1, 417, 418, -1, 420, -1, 422, + 413, 414, -1, -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, - 463, 464, 465, -1, 467, -1, 469, 470, 471, 472, + 463, 464, 465, -1, 467, 468, 469, 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 3, - -1, -1, -1, -1, -1, -1, -1, -1, 511, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 518, -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, @@ -16380,11 +15353,61 @@ static const yytype_int16 yycheck[] = 94, 95, 96, 97, 98, 99, -1, -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, + 124, 125, 126, 127, 128, 129, 130, 131, -1, -1, + 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, + 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, -1, 161, -1, 163, + 164, 165, 166, -1, 168, -1, 170, -1, 172, -1, + 174, 175, 176, -1, 178, -1, 180, -1, 182, 183, + 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, + -1, 195, 196, 197, 198, -1, 200, 201, 202, 203, + 204, 205, 206, -1, 208, -1, 210, 211, 212, 213, + 214, 215, 216, 217, -1, 219, -1, 221, -1, -1, + 224, -1, 226, 227, 228, 229, 230, 231, -1, -1, + 234, -1, 236, -1, -1, 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, -1, 270, 271, 272, 273, + 274, -1, 276, 277, -1, 279, -1, 281, 282, 283, + 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, + 294, -1, -1, 297, 298, 299, -1, 301, -1, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, -1, 319, 320, 321, -1, 323, + 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, + 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, + 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, + -1, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 375, 376, 377, 378, 379, 380, 381, 382, -1, + 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, + -1, 395, 396, 397, 398, -1, 400, 401, 402, 403, + 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, + 414, 415, -1, 417, 418, 419, 420, -1, 422, 423, + 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, + 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, + 444, 445, 446, -1, -1, 449, 450, 451, 452, 453, + 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, + 464, 465, -1, 467, -1, 469, 470, 471, 472, 473, + 474, 475, -1, -1, 478, -1, 480, 481, 482, 483, + 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 499, 500, 501, -1, 3, + 504, 5, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 518, -1, -1, -1, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, + 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, + 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, + 64, -1, -1, 67, 68, 69, 70, 71, 72, 73, + -1, 75, 76, 77, 78, 79, -1, -1, -1, 83, + 84, 85, 86, 87, 88, -1, 90, 91, 92, -1, + 94, 95, 96, 97, 98, 99, -1, -1, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, -1, 161, -1, 163, - 164, 165, 166, -1, 168, -1, 170, -1, -1, -1, + 164, 165, 166, -1, 168, -1, 170, -1, 172, -1, 174, 175, 176, -1, 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, -1, 195, 196, 197, 198, -1, 200, 201, 202, 203, @@ -16399,867 +15422,890 @@ static const yytype_int16 yycheck[] = 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, -1, 301, -1, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, -1, -1, -1, -1, 319, 320, 321, -1, 323, + 314, 315, 316, 317, -1, 319, 320, 321, -1, 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, -1, 365, 366, 367, 368, 369, 370, 371, 372, 373, - 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, + 374, 375, 376, 377, 378, 379, 380, 381, 382, -1, 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, -1, 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, -1, -1, 417, 418, -1, 420, -1, 422, 423, + 414, -1, -1, 417, 418, 419, 420, -1, 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, - 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, + 444, 445, 446, -1, -1, 449, 450, 451, 452, 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, 467, -1, 469, 470, 471, 472, 473, - 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, + 474, 475, -1, -1, 478, -1, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, - 494, 495, 496, 497, 498, 499, 500, 501, 3, 4, - 5, -1, -1, -1, 9, -1, -1, 511, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, - 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, - -1, -1, 37, -1, -1, -1, -1, 42, 43, 44, - -1, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, -1, 59, 60, 61, 62, 63, 64, - -1, -1, 67, 68, 69, 70, 71, 72, 73, -1, - 75, 76, 77, 78, 79, -1, 81, -1, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, -1, 94, - 95, 96, 97, 98, 99, -1, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, - 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, - 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, - 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, -1, 163, 164, - 165, 166, -1, 168, -1, 170, 171, -1, 173, 174, - 175, 176, 177, 178, -1, 180, -1, 182, 183, 184, - 185, -1, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, - 205, 206, -1, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, -1, 219, -1, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, -1, -1, 234, - 235, 236, 237, -1, 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, - -1, 276, 277, 278, 279, -1, 281, 282, 283, 284, - 285, 286, -1, 288, 289, 290, -1, 292, 293, 294, - -1, -1, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - -1, -1, -1, -1, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, - 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, - 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, -1, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, 379, 380, 381, -1, 383, 384, - 385, 386, 387, 388, 389, 390, 391, 392, -1, 394, - 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, - -1, -1, 417, 418, -1, 420, 421, 422, 423, 424, - 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, - 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, - 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, - 465, -1, 467, 468, 469, 470, 471, 472, 473, 474, - 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 499, 500, 501, -1, -1, 8, - -1, -1, 11, -1, 509, 510, 15, 16, 17, 18, - 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 36, -1, -1, - -1, -1, 41, -1, -1, -1, -1, 46, 8, -1, - -1, 11, -1, -1, 53, 15, 16, 17, 18, 19, - 20, 21, -1, -1, -1, -1, 8, -1, -1, 11, - -1, -1, -1, 15, 16, -1, 36, 19, 20, 21, - -1, 80, -1, -1, -1, -1, 46, 8, -1, -1, - 11, -1, -1, 53, 15, 16, 17, 18, 19, 20, - 21, -1, -1, -1, 46, -1, -1, -1, -1, -1, - -1, 53, -1, -1, -1, 36, -1, -1, -1, -1, - 80, -1, -1, -1, -1, 46, -1, 126, -1, -1, - -1, -1, 53, -1, 8, -1, -1, 11, 80, -1, - -1, 15, 16, 17, 18, 19, 20, 21, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 80, - -1, -1, 36, -1, -1, -1, 40, -1, -1, -1, - -1, -1, 46, -1, -1, -1, -1, -1, 177, 53, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 194, -1, -1, -1, -1, - 199, -1, -1, -1, -1, -1, 80, 167, -1, -1, - -1, -1, 172, -1, -1, -1, -1, 177, -1, -1, - -1, -1, -1, 222, 223, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 194, 177, -1, -1, 237, 199, - -1, -1, -1, -1, -1, 166, -1, -1, -1, -1, - -1, -1, 194, -1, -1, -1, 177, 199, -1, -1, - -1, -1, 222, 223, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 194, -1, -1, 275, 237, 199, 278, - 222, 223, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 292, -1, 237, 295, -1, -1, -1, - -1, 222, 223, 177, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 275, 237, -1, 278, -1, - 194, -1, -1, -1, -1, 199, -1, -1, -1, -1, - -1, -1, 292, 275, -1, 295, 278, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 222, 223, - 292, -1, -1, -1, 275, -1, -1, 278, -1, -1, - -1, -1, -1, 237, -1, -1, -1, -1, -1, -1, - -1, 292, -1, -1, 295, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 394, -1, -1, -1, -1, - -1, 275, -1, 324, 278, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 292, -1, - -1, 295, -1, -1, -1, -1, -1, -1, -1, 8, - -1, -1, 11, -1, 394, -1, 15, 16, 17, 18, - 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 394, -1, -1, -1, -1, 36, 457, -1, - -1, -1, -1, -1, -1, -1, -1, 46, -1, -1, - -1, -1, -1, 394, 53, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 80, -1, 502, -1, -1, 505, 506, 507, -1, - 509, 510, 511, 512, 513, 514, -1, -1, -1, -1, - 394, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 502, -1, -1, 505, 506, 507, -1, 509, - 510, 511, 512, 513, 514, -1, -1, -1, -1, -1, - 502, -1, -1, 505, 506, 507, -1, 509, 510, 511, - 512, 513, 514, -1, -1, -1, -1, -1, -1, -1, - -1, 502, -1, -1, 505, 506, 507, -1, 509, 510, - 511, 512, 513, 514, -1, -1, -1, -1, 177, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 8, 194, -1, 11, -1, -1, - 199, 15, 16, 17, 18, 19, 20, 21, 502, -1, - -1, 505, 506, 507, -1, 509, 510, 511, 512, 513, - 514, -1, 36, 222, 223, -1, 40, -1, -1, -1, - -1, -1, 46, -1, -1, -1, -1, -1, 237, 53, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 8, -1, -1, 11, -1, -1, 80, 15, 16, 17, - 18, 19, 20, 21, -1, -1, 275, -1, -1, 278, - -1, -1, -1, -1, -1, -1, -1, -1, 36, -1, - -1, -1, -1, 292, -1, -1, 295, -1, 46, -1, - -1, -1, -1, -1, -1, 53, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 318, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 80, -1, -1, -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, - 19, 20, 21, 177, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 36, -1, -1, - 194, 40, -1, -1, -1, 199, -1, 46, -1, -1, - -1, -1, -1, -1, 53, 394, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 222, 223, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 80, -1, 237, 172, -1, -1, -1, -1, 177, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 194, -1, -1, -1, - -1, 199, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 275, -1, -1, 278, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 222, 223, -1, -1, 292, -1, - -1, 295, -1, -1, -1, -1, -1, -1, -1, 237, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 502, -1, -1, 505, 506, 507, -1, - 509, 510, 511, 512, 513, 514, -1, -1, 177, -1, - -1, -1, -1, -1, -1, -1, -1, 275, -1, -1, - 278, -1, -1, -1, -1, 194, -1, -1, -1, -1, - 199, -1, -1, -1, 292, -1, -1, 295, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 8, -1, - -1, 11, -1, 222, 223, 15, 16, 17, 18, 19, - 20, 21, -1, -1, -1, -1, -1, -1, 237, -1, - 394, -1, -1, -1, -1, -1, 36, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 46, -1, -1, -1, - -1, -1, -1, 53, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 8, 275, -1, 11, 278, - -1, -1, 15, 16, 17, 18, 19, 20, 21, -1, - 80, -1, -1, 292, -1, -1, 295, -1, -1, -1, - -1, -1, -1, 36, -1, -1, 394, -1, -1, -1, - -1, -1, -1, 46, -1, -1, -1, -1, -1, -1, - 53, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 80, 502, -1, - -1, 505, 506, 507, -1, 509, 510, 511, 512, 513, - 514, -1, 8, -1, -1, 11, -1, -1, -1, 15, - 16, 17, 18, 19, 20, 21, -1, 167, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 177, -1, -1, - 36, -1, -1, -1, 40, 394, -1, -1, -1, -1, - 46, -1, -1, -1, 194, -1, -1, 53, -1, 199, - -1, -1, -1, -1, 502, -1, -1, 505, 506, 507, - -1, 509, 510, 511, 512, 513, 514, -1, -1, -1, - -1, -1, 222, 223, 80, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 177, -1, -1, 237, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 194, -1, -1, -1, -1, 199, -1, -1, -1, - -1, 8, -1, -1, 11, -1, -1, -1, 15, 16, - 17, 18, 19, 20, 21, 275, -1, -1, 278, 222, - 223, -1, -1, -1, -1, -1, -1, -1, -1, 36, - -1, -1, 292, 502, 237, 295, 505, 506, 507, 46, - 509, 510, 511, 512, 513, 514, 53, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 177, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 275, 80, -1, 278, -1, -1, 194, -1, - -1, -1, -1, 199, -1, -1, -1, -1, -1, 292, - -1, -1, 295, -1, -1, -1, -1, -1, -1, -1, - -1, 8, -1, -1, 11, -1, 222, 223, 15, 16, - 17, 18, 19, 20, 21, -1, -1, -1, -1, -1, - -1, 237, -1, -1, -1, -1, -1, -1, -1, 36, - -1, -1, -1, -1, 394, -1, -1, -1, -1, 46, - -1, -1, -1, -1, -1, -1, 53, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 275, - -1, -1, 278, -1, -1, -1, -1, -1, -1, -1, - 177, -1, -1, 80, -1, -1, 292, -1, -1, 295, - -1, -1, -1, -1, -1, -1, -1, 194, -1, -1, - 8, 394, 199, 11, -1, -1, -1, 15, 16, 17, - 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 222, 223, -1, 36, -1, - -1, -1, -1, -1, 427, -1, -1, -1, 46, -1, - 237, -1, -1, -1, -1, 53, -1, -1, -1, -1, - -1, -1, 502, -1, -1, 505, 506, 507, -1, 509, - 510, 511, 512, 513, 514, -1, -1, -1, -1, -1, - -1, -1, 80, -1, -1, -1, -1, -1, 275, -1, - 177, 278, -1, -1, -1, -1, -1, -1, 394, -1, - -1, -1, -1, -1, -1, 292, -1, 194, 295, -1, - -1, -1, 199, -1, -1, -1, -1, -1, -1, 502, - -1, -1, 505, 506, 507, -1, 509, 510, 511, 512, - 513, 514, -1, -1, -1, 222, 223, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 237, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 177, - -1, -1, -1, -1, -1, -1, -1, -1, 275, -1, - -1, 278, -1, -1, -1, -1, 194, -1, -1, -1, - -1, 199, -1, -1, -1, 292, 502, 394, 295, 505, - 506, 507, -1, 509, 510, 511, 512, 513, 514, -1, - -1, -1, -1, -1, 222, 223, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 237, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 275, -1, -1, - 278, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 292, -1, -1, 295, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 394, -1, -1, - -1, -1, -1, -1, -1, 502, -1, -1, 505, 506, - 507, -1, 509, 510, 511, 512, 513, 514, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 394, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 502, -1, -1, 505, 506, - 507, -1, 509, 510, 511, 512, 513, 514, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -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, - 5, -1, -1, -1, 502, -1, -1, 505, 506, 507, - -1, 509, 510, 511, 512, 513, 514, 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, 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, + 494, 495, 496, 497, 498, 499, 500, 501, -1, 3, + 504, 5, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 518, -1, -1, -1, 22, 23, + 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, + 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, + 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, + 64, -1, -1, 67, 68, 69, 70, 71, 72, 73, + -1, 75, 76, 77, 78, 79, -1, -1, -1, 83, + 84, 85, 86, 87, 88, -1, 90, 91, 92, -1, + 94, 95, 96, 97, 98, 99, -1, -1, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, + 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, + 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, + 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, -1, 161, -1, 163, + 164, 165, 166, -1, 168, -1, 170, -1, 172, -1, + 174, 175, 176, -1, 178, -1, 180, -1, 182, 183, + 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, + -1, 195, 196, 197, 198, -1, 200, 201, 202, 203, + 204, 205, 206, -1, 208, -1, 210, 211, 212, 213, + 214, 215, 216, 217, -1, 219, -1, 221, -1, -1, + 224, -1, 226, 227, 228, 229, 230, 231, -1, -1, + 234, -1, 236, -1, -1, 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, -1, 270, 271, 272, 273, + 274, -1, 276, 277, -1, 279, -1, 281, 282, 283, + 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, + 294, -1, -1, 297, 298, 299, -1, 301, -1, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, -1, 319, 320, 321, -1, 323, + 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, + 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, + 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, + -1, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 375, 376, 377, 378, 379, 380, 381, 382, -1, + 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, + -1, 395, 396, 397, 398, -1, 400, 401, 402, 403, + 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, + 414, -1, -1, 417, 418, 419, 420, -1, 422, 423, + 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, + 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, + 444, 445, 446, -1, -1, 449, 450, 451, 452, 453, + 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, + 464, 465, -1, 467, -1, 469, 470, 471, 472, 473, + 474, 475, -1, -1, 478, -1, 480, 481, 482, 483, + 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 499, 500, 501, -1, 3, + 504, 5, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 518, -1, -1, -1, 22, 23, + 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, + 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, + 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, + 64, -1, -1, 67, 68, 69, 70, 71, 72, 73, + -1, 75, 76, 77, 78, 79, -1, -1, -1, 83, + 84, 85, 86, 87, 88, -1, 90, 91, 92, -1, + 94, 95, 96, 97, 98, 99, -1, -1, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, + 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, + 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, + 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, -1, 161, -1, 163, + 164, 165, 166, -1, 168, -1, 170, -1, -1, -1, + 174, 175, 176, -1, 178, -1, 180, -1, 182, 183, + 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, + -1, 195, 196, 197, 198, -1, 200, 201, 202, 203, + 204, 205, 206, -1, 208, -1, 210, 211, 212, 213, + 214, 215, 216, 217, -1, 219, -1, 221, -1, -1, + 224, -1, 226, 227, 228, 229, 230, 231, -1, -1, + 234, -1, 236, -1, -1, 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, -1, 270, 271, 272, 273, + 274, -1, 276, 277, -1, 279, -1, 281, 282, 283, + 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, + 294, -1, -1, 297, 298, 299, -1, 301, -1, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, -1, -1, -1, -1, 319, 320, 321, -1, 323, + 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, + 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, + 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, + -1, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, + 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, + -1, 395, 396, 397, 398, -1, 400, 401, 402, 403, + 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, + 414, -1, -1, 417, 418, -1, 420, -1, 422, 423, + 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, + 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, + 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, + 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, + 464, 465, -1, 467, -1, 469, 470, 471, 472, 473, + 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, + 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 499, 500, 501, 3, -1, + 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 518, -1, -1, 22, 23, 24, + 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, + -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, + -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, + -1, -1, 67, 68, 69, 70, 71, 72, 73, -1, + 75, 76, 77, 78, 79, -1, -1, -1, 83, 84, + 85, 86, 87, 88, -1, 90, 91, 92, -1, 94, + 95, 96, 97, 98, 99, -1, -1, 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, + 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, + 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, + 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, + 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, -1, 161, -1, 163, 164, + 165, 166, -1, 168, -1, 170, -1, -1, -1, 174, + 175, 176, -1, 178, -1, 180, -1, 182, 183, 184, + 185, -1, 187, 188, 189, 190, 191, 192, 193, -1, + 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, + 205, 206, -1, 208, -1, 210, 211, 212, 213, 214, + 215, 216, 217, -1, 219, -1, 221, -1, -1, 224, + -1, 226, 227, 228, 229, 230, 231, -1, -1, 234, + -1, 236, -1, -1, 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, + 265, 266, 267, 268, -1, 270, 271, 272, 273, 274, + -1, 276, 277, -1, 279, -1, 281, 282, 283, 284, + 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, + -1, -1, 297, 298, 299, -1, 301, -1, 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, + -1, -1, -1, -1, 319, 320, 321, -1, 323, 324, + 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, + 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, + 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, -1, 362, 363, -1, 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, + 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, + 385, 386, 387, 388, 389, 390, 391, 392, -1, -1, + 395, 396, 397, 398, -1, 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, + -1, -1, 417, 418, -1, 420, -1, 422, 423, 424, + 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, + 435, 436, 437, -1, 439, 440, 441, 442, 443, 444, + 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, + 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, + 465, -1, 467, -1, 469, 470, 471, 472, 473, 474, + 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 499, 500, 501, 3, -1, -1, + 495, 496, 497, 498, 499, 500, 501, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 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, 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, + -1, -1, -1, 518, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, + 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, + 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, + -1, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, -1, -1, 83, 84, 85, + 86, 87, 88, -1, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, -1, 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, + 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, + -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, + 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, -1, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, -1, -1, -1, 174, 175, + 176, -1, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, -1, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, -1, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, -1, -1, 224, -1, + 226, 227, 228, 229, 230, 231, -1, -1, 234, -1, + 236, -1, -1, 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, + 266, 267, 268, -1, 270, 271, 272, 273, 274, -1, + 276, 277, -1, 279, -1, 281, 282, 283, 284, 285, + 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, + -1, 297, 298, 299, -1, 301, -1, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, -1, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, -1, 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, + 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, -1, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, -1, 420, -1, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 436, 437, -1, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, 465, + -1, 467, -1, 469, 470, 471, 472, 473, 474, 475, + -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, - 496, 497, 498, 499, 500, 501, 3, -1, -1, -1, + 496, 497, 498, 499, 500, 501, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 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, 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, + -1, -1, 518, -1, -1, 22, 23, 24, 25, 26, + 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, + 47, 48, -1, 50, 51, 52, 53, 54, -1, 56, + 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, + 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, + 77, 78, 79, -1, -1, -1, 83, 84, 85, 86, + 87, 88, -1, 90, 91, 92, -1, 94, 95, 96, + 97, 98, 99, -1, -1, 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, + -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, + -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, + 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, + -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, + 157, 158, 159, -1, 161, -1, 163, 164, 165, 166, + -1, 168, -1, 170, -1, -1, -1, 174, 175, 176, + -1, 178, -1, 180, -1, 182, 183, 184, 185, -1, + 187, 188, 189, 190, 191, 192, 193, -1, 195, 196, + 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, + -1, 208, -1, 210, 211, 212, 213, 214, 215, 216, + 217, -1, 219, -1, 221, -1, -1, 224, -1, 226, + 227, 228, 229, 230, 231, -1, -1, 234, -1, 236, + -1, -1, 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, + 267, 268, -1, 270, 271, 272, 273, 274, -1, 276, + 277, -1, 279, -1, 281, 282, 283, 284, 285, 286, + -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, + 297, 298, 299, -1, 301, -1, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, + -1, -1, 319, 320, 321, -1, 323, 324, 325, 326, + 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, 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, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 360, -1, 362, 363, -1, 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, + 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, + 387, 388, 389, 390, 391, 392, -1, -1, 395, 396, + 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, + 417, 418, -1, 420, -1, 422, 423, 424, 425, 426, + -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, + 437, -1, 439, 440, 441, 442, 443, 444, 445, 446, + -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, + -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, + 467, -1, 469, 470, 471, 472, 473, 474, 475, -1, + -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, 3, -1, -1, -1, -1, + 497, 498, 499, 500, 501, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 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, 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, + -1, 518, -1, -1, 22, 23, 24, 25, 26, 27, + 28, 29, -1, 31, 32, 33, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 43, 44, -1, 46, 47, + 48, -1, 50, 51, 52, 53, 54, -1, 56, 57, + -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, + 68, 69, 70, 71, 72, 73, -1, 75, 76, 77, + 78, 79, -1, -1, -1, 83, 84, 85, 86, 87, + 88, -1, 90, 91, 92, -1, 94, 95, 96, 97, + 98, 99, -1, -1, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, + 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, + 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, + 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, 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, + 158, 159, -1, 161, -1, 163, 164, 165, 166, -1, + 168, -1, 170, -1, -1, -1, 174, 175, 176, -1, + 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, + 188, 189, 190, 191, 192, 193, -1, 195, 196, 197, + 198, -1, 200, 201, 202, 203, 204, 205, 206, -1, + 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, + -1, 219, -1, 221, -1, -1, 224, -1, 226, 227, + 228, 229, 230, 231, -1, -1, 234, -1, 236, -1, + -1, 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, + 268, -1, 270, 271, 272, 273, 274, -1, 276, 277, + -1, 279, -1, 281, 282, 283, 284, 285, 286, -1, + 288, 289, -1, -1, 292, 293, 294, -1, -1, 297, + 298, 299, -1, 301, -1, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, + -1, 319, 320, 321, -1, 323, 324, 325, 326, 327, + 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, + 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, + 358, 359, 360, -1, 362, 363, -1, 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, + 378, 379, 380, 381, -1, -1, 384, 385, 386, 387, + 388, 389, 390, 391, 392, -1, -1, 395, 396, 397, + 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, + 408, 409, 410, 411, 412, 413, 414, -1, -1, 417, + 418, -1, 420, -1, 422, 423, 424, 425, 426, -1, + 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, + -1, 439, 440, 441, 442, 443, 444, 445, 446, -1, + -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, + 458, 459, 460, 461, 462, 463, 464, 465, -1, 467, + -1, 469, 470, 471, 472, 473, 474, 475, -1, -1, + 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 498, 499, 500, 501, 3, -1, -1, -1, -1, -1, + 498, 499, 500, 501, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 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, 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, + 518, -1, -1, 22, 23, 24, 25, 26, 27, 28, + 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 43, 44, -1, 46, 47, 48, + -1, 50, 51, 52, 53, 54, -1, 56, 57, -1, + 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, + 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, + 79, -1, -1, -1, 83, 84, 85, 86, 87, 88, + -1, 90, 91, 92, -1, 94, 95, 96, 97, 98, + 99, -1, -1, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, + -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, + 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, + -1, 140, 141, 142, -1, 144, 145, 146, -1, 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, + 159, -1, 161, -1, 163, 164, 165, 166, -1, 168, + -1, 170, -1, -1, -1, 174, 175, 176, -1, 178, + -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, + 189, 190, 191, 192, 193, -1, 195, 196, 197, 198, + -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, + -1, 210, 211, 212, 213, 214, 215, 216, 217, -1, + 219, -1, 221, -1, -1, 224, -1, 226, 227, 228, + 229, 230, 231, -1, -1, 234, -1, 236, -1, -1, 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, + -1, 270, 271, 272, 273, 274, -1, 276, 277, -1, + 279, -1, 281, 282, 283, 284, 285, 286, -1, 288, + 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, + 299, -1, 301, -1, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, + 319, 320, 321, -1, 323, 324, 325, 326, 327, 328, + -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, + 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, + 359, 360, -1, 362, 363, -1, 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, + 379, 380, 381, -1, -1, 384, 385, 386, 387, 388, + 389, 390, 391, 392, -1, -1, 395, 396, 397, 398, + -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, + 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, + -1, 420, -1, 422, 423, 424, 425, 426, -1, 428, + 429, 430, -1, -1, 433, 434, 435, 436, 437, -1, + 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, + 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, + 459, 460, 461, 462, 463, 464, 465, -1, 467, -1, + 469, 470, 471, 472, 473, 474, 475, -1, -1, 478, + -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 3, -1, 5, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 518, -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, - -1, 31, 32, 33, -1, -1, -1, 37, -1, -1, - -1, -1, 42, 43, 44, -1, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, + -1, 31, 32, 33, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, + 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, - -1, 81, -1, 83, 84, 85, 86, 87, 88, 89, + -1, -1, -1, 83, 84, 85, 86, 87, 88, -1, 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, - -1, 101, 102, 103, 104, 105, 106, 107, 108, 109, + -1, -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, -1, 163, 164, 165, 166, -1, 168, -1, - 170, 171, -1, 173, 174, 175, 176, 177, 178, -1, + -1, 161, -1, 163, 164, 165, 166, -1, 168, -1, + 170, -1, -1, -1, 174, 175, 176, -1, 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, -1, - 200, 201, 202, 203, 204, 205, 206, -1, 208, 209, + 190, 191, 192, 193, -1, 195, 196, 197, 198, -1, + 200, 201, 202, 203, 204, 205, 206, -1, 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, - -1, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, -1, -1, 234, 235, 236, 237, -1, 239, + -1, 221, -1, -1, 224, -1, 226, 227, 228, 229, + 230, 231, -1, -1, 234, -1, 236, -1, -1, 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, -1, 276, 277, 278, 279, + 260, 261, 262, 263, 264, 265, 266, 267, 268, -1, + 270, 271, 272, 273, 274, -1, 276, 277, -1, 279, -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, - 290, -1, 292, 293, 294, -1, -1, 297, 298, 299, - 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, + -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, + -1, 301, -1, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, - 320, 321, 322, 323, 324, 325, 326, 327, 328, -1, + 320, 321, -1, 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, + 360, -1, 362, 363, -1, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, - 380, 381, -1, 383, 384, 385, 386, 387, 388, 389, - 390, 391, 392, -1, 394, 395, 396, 397, 398, -1, + 380, 381, -1, -1, 384, 385, 386, 387, 388, 389, + 390, 391, 392, -1, -1, 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, -1, - 420, 421, 422, 423, 424, 425, 426, -1, 428, 429, - 430, -1, -1, 433, 434, 435, 436, 437, 438, 439, + 420, -1, 422, 423, 424, 425, 426, -1, 428, 429, + 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, - 460, 461, 462, 463, 464, 465, -1, 467, 468, 469, + 460, 461, 462, 463, 464, 465, -1, 467, -1, 469, 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, - 500, 501, 3, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 500, 501, 3, -1, 5, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 518, -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, - 31, 32, 33, 34, 35, -1, 37, -1, -1, -1, - -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, - 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, + 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, + 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, - 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, + -1, -1, 83, 84, 85, 86, 87, 88, -1, 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, - 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, -1, 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, - 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, + -1, -1, -1, 174, 175, 176, -1, 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, - 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, - 201, 202, 203, 204, 205, 206, -1, 208, 209, 210, + 191, 192, 193, -1, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, - 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, - 231, -1, -1, 234, 235, 236, 237, -1, 239, 240, + 221, -1, -1, 224, -1, 226, 227, 228, 229, 230, + 231, -1, -1, 234, -1, 236, -1, -1, 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, -1, 276, 277, 278, 279, -1, + 261, 262, 263, 264, 265, 266, 267, 268, -1, 270, + 271, 272, 273, 274, -1, 276, 277, -1, 279, -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, - -1, 292, 293, 294, -1, -1, 297, 298, 299, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + -1, 292, 293, 294, -1, -1, 297, 298, 299, -1, + 301, -1, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, + 321, -1, 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, + -1, 362, 363, -1, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, - 381, -1, 383, 384, 385, 386, 387, 388, 389, 390, - 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, + 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, + 391, 392, -1, -1, 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, - 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, - 461, 462, 463, 464, 465, -1, 467, 468, 469, 470, + 461, 462, 463, 464, 465, -1, 467, -1, 469, 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 3, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 518, -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, -1, - 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, - 62, 63, 64, -1, 66, 67, 68, 69, 70, 71, - 72, 73, -1, 75, 76, 77, 78, 79, -1, 81, - -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, + -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, + 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, + 62, 63, 64, -1, -1, 67, 68, 69, 70, 71, + 72, 73, -1, 75, 76, 77, 78, 79, -1, -1, + -1, 83, 84, 85, 86, 87, 88, -1, 90, 91, + 92, -1, 94, 95, 96, 97, 98, 99, -1, -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, -1, 161, - -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, - -1, 173, 174, 175, 176, 177, 178, -1, 180, -1, + -1, 163, 164, 165, 166, -1, 168, -1, 170, -1, + -1, -1, 174, 175, 176, -1, 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, - 202, 203, 204, 205, 206, -1, 208, 209, 210, 211, + 192, 193, -1, 195, 196, 197, 198, -1, 200, 201, + 202, 203, 204, 205, 206, -1, 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - -1, -1, 234, 235, 236, 237, -1, 239, 240, 241, + -1, -1, 224, -1, 226, 227, 228, 229, 230, 231, + -1, -1, 234, -1, 236, -1, -1, 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, -1, 276, 277, 278, 279, -1, 281, + 262, 263, 264, 265, 266, 267, 268, -1, 270, 271, + 272, 273, 274, -1, 276, 277, -1, 279, -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, - 292, 293, 294, -1, -1, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 292, 293, 294, -1, -1, 297, 298, 299, -1, 301, + -1, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, - 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, + -1, 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, - 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 362, 363, -1, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, - 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, + 392, -1, -1, 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, - 412, 413, 414, -1, -1, 417, 418, -1, 420, 421, + 412, 413, 414, -1, -1, 417, 418, -1, 420, -1, 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, - 462, 463, 464, 465, -1, 467, 468, 469, 470, 471, + 462, 463, 464, 465, -1, 467, -1, 469, 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, + -1, -1, -1, -1, -1, -1, 518, -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, - 33, -1, -1, -1, -1, -1, -1, -1, -1, 42, - 43, 44, -1, 46, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, -1, 59, 60, 61, 62, + 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, + 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, 71, 72, - 73, -1, 75, 76, 77, 78, 79, -1, 81, -1, - 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, - -1, 94, 95, 96, 97, 98, 99, -1, 101, 102, + 73, -1, 75, 76, 77, 78, 79, -1, -1, -1, + 83, 84, 85, 86, 87, 88, -1, 90, 91, 92, + -1, 94, 95, 96, 97, 98, 99, -1, -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, -1, 161, -1, - 163, 164, 165, 166, -1, 168, -1, 170, 171, -1, - 173, 174, 175, 176, 177, 178, -1, 180, -1, 182, + 163, 164, 165, 166, -1, 168, -1, 170, -1, -1, + -1, 174, 175, 176, -1, 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, -1, 200, 201, 202, - 203, 204, 205, 206, -1, 208, 209, 210, 211, 212, - 213, 214, 215, 216, 217, -1, 219, -1, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, 231, -1, - -1, 234, 235, 236, 237, -1, 239, 240, 241, 242, + 193, -1, 195, 196, 197, 198, -1, 200, 201, 202, + 203, 204, 205, 206, -1, 208, -1, 210, 211, 212, + 213, 214, 215, 216, 217, -1, 219, -1, 221, -1, + -1, 224, -1, 226, 227, 228, 229, 230, 231, -1, + -1, 234, -1, 236, -1, -1, 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, -1, 276, 277, 278, 279, -1, 281, 282, + 263, 264, 265, 266, 267, 268, -1, 270, 271, 272, + 273, 274, -1, 276, 277, -1, 279, -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, - 293, 294, -1, -1, 297, 298, 299, 300, 301, 302, + 293, 294, -1, -1, 297, 298, 299, -1, 301, -1, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, -1, -1, -1, -1, 319, 320, 321, 322, + 313, 314, -1, -1, -1, -1, 319, 320, 321, -1, 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, + 363, -1, 365, 366, 367, 368, 369, 370, 371, 372, + 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, + -1, 384, 385, 386, 387, 388, 389, 390, 391, 392, + -1, -1, 395, 396, 397, 398, -1, 400, 401, 402, + 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, + 413, 414, -1, -1, 417, 418, -1, 420, -1, 422, + 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, + 433, 434, 435, 436, 437, -1, 439, 440, 441, 442, + 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, + 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, + 463, 464, 465, -1, 467, -1, 469, 470, 471, 472, + 473, 474, 475, -1, -1, 478, -1, -1, 481, 482, + 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, + 493, 494, 495, 496, 497, 498, 499, 500, 501, -1, + 3, 4, 5, -1, -1, 8, 9, -1, -1, -1, + -1, -1, 15, 16, -1, 518, 19, 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, + -1, 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, -1, 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, -1, + 153, 154, 155, 156, 157, 158, -1, 160, 161, 162, + 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, + 173, 174, 175, 176, 177, 178, 179, 180, 181, -1, + -1, 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, -1, 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, -1, 282, + 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, + 293, 294, 295, 296, 297, 298, -1, 300, 301, 302, + -1, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 320, -1, 322, + 323, 324, -1, 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, -1, 415, 416, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, + 433, 434, -1, 436, -1, 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, + -1, 464, 465, 466, 467, 468, 469, 470, 471, 472, + 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, + 483, 484, 485, 486, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 498, 499, 500, 501, -1, + 3, -1, 505, 506, 507, 8, 509, 510, 511, 512, + 513, 514, 15, 16, -1, -1, 19, 20, 21, 22, + 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, + 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, + 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, + 63, 64, -1, -1, 67, 68, 69, 70, 71, 72, + 73, -1, 75, 76, 77, 78, 79, -1, -1, -1, + 83, 84, 85, 86, 87, 88, -1, 90, 91, 92, + -1, 94, 95, 96, 97, 98, 99, -1, -1, 102, + 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, + 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, + 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, + -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, + -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, + 153, 154, 155, 156, 157, 158, 159, -1, 161, -1, + 163, 164, 165, 166, -1, 168, -1, 170, -1, -1, + -1, 174, 175, 176, -1, 178, -1, 180, -1, 182, + 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, + 193, -1, 195, 196, 197, 198, -1, 200, 201, 202, + 203, 204, 205, 206, -1, 208, -1, 210, 211, 212, + 213, 214, 215, 216, 217, -1, 219, -1, 221, -1, + -1, 224, -1, 226, 227, 228, 229, 230, 231, -1, + -1, 234, -1, 236, -1, -1, 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, -1, 270, 271, 272, + 273, 274, -1, 276, 277, -1, 279, -1, 281, 282, + 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, + 293, 294, -1, -1, 297, 298, 299, -1, 301, -1, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, -1, -1, -1, -1, 319, 320, 321, -1, + 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, + 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, + 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, + 363, -1, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, 392, - -1, 394, 395, 396, 397, 398, -1, 400, 401, 402, + -1, -1, 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, - 413, 414, -1, -1, 417, 418, -1, 420, 421, 422, + 413, 414, -1, -1, 417, 418, -1, 420, -1, 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, - 463, 464, 465, -1, 467, 468, 469, 470, 471, 472, + 463, 464, 465, -1, 467, -1, 469, 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, - 493, 494, 495, 496, 497, 498, 499, 500, 501, 3, + 493, 494, 495, 496, 497, 498, 499, 500, 501, -1, + -1, -1, 505, 506, 507, -1, 509, 510, 511, 512, + 513, 514, 8, -1, -1, 11, -1, -1, -1, 15, + 16, 17, 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, - 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, - 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, - 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, - 64, -1, -1, 67, 68, 69, 70, 71, 72, 73, - 74, 75, 76, 77, 78, 79, -1, -1, 82, 83, - 84, 85, 86, 87, 88, -1, 90, 91, 92, 93, - 94, 95, 96, 97, 98, 99, -1, -1, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, - 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, - 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, - 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, -1, 161, -1, 163, - 164, 165, 166, -1, 168, 169, 170, -1, -1, -1, - 174, 175, 176, -1, 178, -1, 180, -1, 182, 183, - 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, - -1, 195, 196, 197, 198, -1, 200, 201, 202, 203, - 204, 205, 206, -1, 208, -1, 210, 211, 212, 213, - 214, 215, 216, 217, -1, 219, -1, 221, -1, -1, - 224, -1, 226, 227, 228, 229, 230, 231, -1, -1, - 234, -1, 236, -1, -1, 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, -1, 270, 271, 272, 273, - 274, -1, 276, 277, -1, 279, -1, 281, 282, 283, - 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, - 294, -1, -1, 297, 298, 299, -1, 301, -1, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, -1, -1, -1, -1, 319, 320, 321, -1, 323, - 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, - 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, - 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, - 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, - -1, 365, 366, 367, 368, 369, 370, 371, 372, 373, - 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, - 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, - -1, 395, 396, 397, 398, -1, 400, 401, 402, 403, - 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, -1, -1, 417, 418, -1, 420, -1, 422, 423, - 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, - 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, - 444, 445, 446, -1, 448, 449, 450, 451, -1, 453, - 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, - 464, 465, -1, 467, -1, 469, 470, 471, 472, 473, - 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, - 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, - 494, 495, 496, 497, 498, 499, 500, 501, 3, -1, + 36, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 46, 8, -1, -1, 11, -1, -1, 53, 15, 16, + 17, 18, 19, 20, 21, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 36, + -1, -1, -1, -1, 80, -1, -1, -1, -1, 46, + 8, -1, -1, 11, -1, -1, 53, 15, 16, 17, + 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 36, -1, + -1, -1, -1, 80, -1, -1, -1, -1, 46, -1, + -1, -1, -1, -1, -1, 53, -1, -1, 8, -1, + -1, 11, -1, -1, -1, 15, 16, 17, 18, 19, + 20, 21, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 80, -1, -1, -1, 36, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 46, 8, -1, -1, + 11, 177, -1, 53, 15, 16, 17, 18, 19, 20, + 21, -1, -1, -1, -1, -1, -1, -1, 194, -1, + -1, -1, -1, 199, -1, 36, -1, -1, -1, -1, + 80, -1, -1, -1, -1, 46, -1, -1, -1, -1, + 177, -1, 53, -1, -1, -1, 222, 223, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 194, -1, -1, + -1, 237, 199, -1, -1, -1, -1, -1, -1, 80, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 177, + -1, -1, -1, -1, -1, 222, 223, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 194, -1, -1, 275, + 237, 199, 278, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 292, -1, -1, 295, + -1, -1, -1, -1, 222, 223, -1, 177, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 275, 237, + -1, 278, -1, -1, 194, -1, -1, -1, -1, 199, + -1, -1, -1, -1, -1, 292, -1, -1, 295, -1, + -1, -1, -1, -1, -1, -1, 177, -1, -1, -1, + -1, -1, 222, 223, -1, -1, -1, 275, -1, -1, + 278, -1, -1, 194, -1, -1, -1, 237, 199, -1, + -1, -1, -1, -1, 292, -1, -1, 295, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 222, 223, -1, -1, -1, -1, -1, 394, -1, + -1, -1, -1, -1, -1, 275, 237, -1, 278, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 292, -1, -1, 295, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 394, -1, -1, + -1, -1, -1, -1, 275, -1, -1, 278, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 292, -1, -1, 295, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 394, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 502, -1, -1, 505, + 506, 507, -1, 509, 510, 511, 512, 513, 514, -1, + -1, -1, -1, 519, 394, -1, -1, -1, -1, -1, + 8, -1, -1, 11, -1, -1, -1, 15, 16, 17, + 18, 19, 20, 21, -1, 502, -1, -1, 505, 506, + 507, -1, 509, 510, 511, 512, 513, 514, 36, -1, + -1, -1, 519, 394, -1, -1, -1, -1, 46, -1, + -1, -1, -1, -1, -1, 53, -1, -1, -1, -1, + -1, -1, -1, -1, 502, -1, -1, 505, 506, 507, + -1, 509, 510, 511, 512, 513, 514, -1, -1, -1, + -1, 519, 80, -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, 19, 20, + 21, -1, 502, -1, -1, 505, 506, 507, -1, 509, + 510, 511, 512, 513, 514, 36, -1, -1, -1, 519, + -1, -1, -1, -1, -1, 46, 8, -1, -1, 11, + -1, -1, 53, 15, 16, 17, 18, 19, 20, 21, + -1, 502, -1, -1, 505, 506, 507, -1, 509, 510, + 511, 512, 513, 514, 36, -1, -1, -1, 519, 80, + -1, -1, -1, -1, 46, 8, -1, -1, 11, 177, + -1, 53, 15, 16, 17, 18, 19, 20, 21, -1, + -1, -1, -1, -1, -1, -1, 194, -1, -1, -1, + -1, 199, -1, 36, -1, -1, -1, -1, 80, -1, + -1, -1, -1, 46, -1, -1, -1, -1, -1, -1, + 53, -1, -1, -1, 222, 223, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 237, + -1, -1, -1, -1, -1, -1, -1, 80, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 8, -1, -1, 11, 177, -1, -1, 15, + 16, 17, 18, 19, 20, 21, -1, 275, -1, -1, + 278, -1, -1, 194, -1, -1, -1, -1, 199, -1, + 36, -1, -1, -1, 292, -1, -1, 295, -1, -1, + 46, -1, -1, -1, -1, 177, -1, 53, -1, -1, + -1, 222, 223, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 194, -1, -1, -1, 237, 199, -1, -1, + -1, -1, -1, -1, 80, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 177, -1, -1, -1, -1, -1, + 222, 223, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 194, -1, -1, 275, 237, 199, 278, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 292, -1, -1, 295, -1, -1, -1, -1, 222, + 223, -1, -1, -1, -1, -1, 394, -1, -1, -1, + -1, -1, -1, 275, 237, -1, 278, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 292, -1, -1, 295, -1, -1, -1, -1, -1, -1, + -1, 177, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 275, -1, -1, 278, -1, -1, 194, -1, + -1, -1, -1, 199, -1, -1, -1, -1, -1, 292, + -1, -1, 295, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 222, 223, -1, -1, + -1, -1, -1, 394, -1, -1, -1, -1, -1, -1, + -1, 237, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 502, -1, -1, 505, 506, 507, + -1, 509, 510, 511, 512, 513, 514, -1, -1, -1, + -1, 519, 394, -1, -1, -1, -1, -1, -1, 275, + -1, -1, 278, -1, -1, -1, -1, -1, -1, -1, + 8, -1, -1, 11, -1, -1, 292, 15, 16, 295, + -1, 19, 20, 21, -1, -1, -1, -1, -1, 8, + -1, 394, 11, -1, -1, -1, 15, 16, 17, 18, + 19, 20, 21, -1, -1, -1, -1, -1, 46, -1, + -1, -1, -1, -1, -1, 53, -1, 36, -1, -1, + -1, 502, -1, -1, 505, 506, 507, 46, 509, 510, + 511, 512, 513, 514, 53, -1, -1, -1, 519, -1, + -1, -1, 80, -1, -1, -1, 8, -1, -1, 11, + -1, -1, -1, 15, 16, 17, 18, 19, 20, 21, + 502, 80, -1, 505, 506, 507, -1, 509, 510, 511, + 512, 513, 514, -1, 36, -1, -1, 519, 394, -1, + -1, -1, -1, -1, 46, -1, -1, -1, -1, -1, + -1, 53, -1, -1, -1, -1, -1, -1, -1, 502, + -1, -1, 505, 506, 507, -1, 509, 510, 511, 512, + 513, 514, -1, -1, 517, -1, -1, -1, 80, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 177, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 194, -1, 177, -1, + -1, 199, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 194, -1, -1, -1, -1, + 199, -1, -1, -1, 222, 223, 502, -1, -1, 505, + 506, 507, -1, 509, 510, 511, 512, 513, 514, 237, + -1, 517, -1, 222, 223, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 177, -1, -1, 237, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 194, -1, -1, -1, -1, 199, -1, -1, + 278, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 292, -1, 275, -1, -1, 278, + 222, 223, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 292, -1, 237, 295, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 275, -1, -1, 278, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 292, -1, -1, 295, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 394, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 394, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 394, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 502, -1, -1, 505, 506, 507, + -1, 509, 510, 511, 512, 513, 514, -1, -1, -1, + -1, -1, -1, 502, -1, -1, 505, 506, 507, -1, + 509, 510, 511, 512, 513, 514, -1, -1, 517, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, - 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, - -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, - -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, - -1, -1, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, -1, -1, -1, 83, 84, - 85, 86, 87, 88, -1, 90, 91, 92, 93, 94, - 95, 96, 97, 98, 99, -1, -1, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, - 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, - 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, - 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, -1, 161, -1, 163, 164, - 165, 166, -1, 168, 169, 170, -1, -1, -1, 174, - 175, 176, -1, 178, -1, 180, -1, 182, 183, 184, - 185, -1, 187, 188, 189, 190, 191, 192, 193, -1, - 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, - 205, 206, -1, 208, -1, 210, 211, 212, 213, 214, - 215, 216, 217, -1, 219, -1, 221, -1, -1, 224, - -1, 226, 227, 228, 229, 230, 231, -1, -1, 234, - -1, 236, 237, -1, 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, -1, 270, 271, 272, 273, 274, - -1, 276, 277, -1, 279, -1, 281, 282, 283, 284, - 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, - -1, -1, 297, 298, 299, -1, 301, -1, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - -1, -1, -1, -1, 319, 320, 321, -1, 323, 324, - 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, - 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, - 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, -1, 362, 363, -1, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, - 385, 386, 387, 388, 389, 390, 391, 392, -1, -1, - 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, - -1, -1, 417, 418, -1, 420, -1, 422, 423, 424, - 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, - 435, 436, 437, -1, 439, 440, 441, 442, 443, 444, - 445, 446, -1, 448, 449, 450, 451, -1, 453, 454, - 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, - 465, -1, 467, -1, 469, 470, 471, 472, 473, 474, - 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 499, 500, 501, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, - 26, 27, 28, 29, -1, 31, 32, 33, 34, 35, - -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, - 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, - 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, - -1, 67, 68, 69, 70, 71, 72, 73, -1, 75, - 76, 77, 78, 79, -1, -1, -1, 83, 84, 85, - 86, 87, 88, -1, 90, 91, 92, -1, 94, 95, - 96, 97, 98, 99, -1, -1, 102, 103, 104, 105, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 3, -1, -1, + 502, -1, -1, 505, 506, 507, -1, 509, 510, 511, + 512, 513, 514, -1, -1, 517, 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, 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, -1, 118, -1, 120, 121, 122, 123, 124, 125, - -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, - 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, - 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, -1, 161, -1, 163, 164, 165, - 166, -1, 168, -1, 170, -1, -1, -1, 174, 175, - 176, -1, 178, -1, 180, -1, 182, 183, 184, 185, - -1, 187, 188, 189, 190, 191, 192, 193, -1, 195, - 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, - 206, -1, 208, -1, 210, 211, 212, 213, 214, 215, - 216, 217, -1, 219, -1, 221, -1, -1, 224, -1, - 226, 227, 228, 229, 230, 231, -1, -1, 234, -1, - 236, -1, -1, 239, 240, 241, 242, 243, 244, 245, + 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, -1, 270, 271, 272, 273, 274, -1, - 276, 277, -1, 279, -1, 281, 282, 283, 284, 285, - 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, - -1, 297, 298, 299, -1, 301, -1, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, - -1, -1, -1, 319, 320, 321, -1, 323, 324, 325, - 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, - -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, - 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, -1, 362, 363, -1, 365, + 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, -1, -1, 384, 385, - 386, 387, 388, 389, 390, 391, 392, -1, -1, 395, - 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, - -1, 417, 418, -1, 420, -1, 422, 423, 424, 425, - 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, - 436, 437, -1, 439, 440, 441, 442, 443, 444, 445, - 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, - 456, -1, 458, 459, 460, 461, 462, 463, 464, 465, - -1, 467, -1, 469, 470, 471, 472, 473, 474, 475, - -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, + 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, 497, 498, 499, 500, 501, 3, -1, 5, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 496, 497, 498, 499, 500, 501, 3, -1, -1, -1, + -1, -1, -1, -1, -1, 511, -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, -1, -1, -1, + 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, @@ -17306,8 +16352,8 @@ static const yytype_int16 yycheck[] = 467, -1, 469, 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, 3, -1, 5, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 497, 498, 499, 500, 501, 3, -1, -1, -1, -1, + -1, -1, -1, -1, 511, -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, 47, @@ -17335,7 +16381,7 @@ static const yytype_int16 yycheck[] = 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, -1, 270, 271, 272, 273, 274, -1, 276, 277, -1, 279, -1, 281, 282, 283, 284, 285, 286, -1, - 288, 289, -1, 291, 292, 293, 294, -1, -1, 297, + 288, 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, -1, 301, -1, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, -1, 323, 324, 325, 326, 327, @@ -17356,465 +16402,705 @@ static const yytype_int16 yycheck[] = -1, 469, 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 498, 499, 500, 501, 3, -1, 5, -1, -1, -1, + 498, 499, 500, 501, 3, 4, 5, -1, -1, -1, + 9, -1, -1, 511, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, + 29, -1, 31, 32, 33, -1, -1, -1, 37, -1, + -1, -1, -1, 42, 43, 44, -1, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, -1, + 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, + 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, + 79, -1, 81, -1, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, -1, 94, 95, 96, 97, 98, + 99, -1, 101, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, + -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, + 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, + -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, + 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, -1, 163, 164, 165, 166, -1, 168, + -1, 170, 171, -1, 173, 174, 175, 176, 177, 178, + -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, -1, + 219, -1, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, -1, -1, 234, 235, 236, 237, -1, + 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, -1, 276, 277, 278, + 279, -1, 281, 282, 283, 284, 285, 286, -1, 288, + 289, 290, -1, 292, 293, 294, -1, -1, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, + 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, + -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, + 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, + 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, + 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, + 379, 380, 381, -1, 383, 384, 385, 386, 387, 388, + 389, 390, 391, 392, -1, 394, 395, 396, 397, 398, + -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, + 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, + -1, 420, 421, 422, 423, 424, 425, 426, -1, 428, + 429, 430, -1, -1, 433, 434, 435, 436, 437, 438, + 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, + 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, + 459, 460, 461, 462, 463, 464, 465, -1, 467, 468, + 469, 470, 471, 472, 473, 474, 475, -1, -1, 478, + -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, + 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, + 499, 500, 501, -1, -1, 8, -1, -1, 11, -1, + 509, 510, 15, 16, 17, 18, 19, 20, 21, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 36, -1, -1, -1, -1, 41, -1, + -1, -1, -1, 46, 8, -1, -1, 11, -1, -1, + 53, 15, 16, 17, 18, 19, 20, 21, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 36, -1, -1, -1, -1, 80, -1, -1, + -1, -1, 46, 8, -1, -1, 11, -1, -1, 53, + 15, 16, 17, 18, 19, 20, 21, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 36, -1, -1, -1, -1, 80, -1, -1, -1, + -1, 46, -1, 126, -1, -1, -1, -1, 53, -1, + 8, -1, -1, 11, -1, -1, -1, 15, 16, 17, + 18, 19, 20, 21, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 80, -1, -1, 36, -1, + -1, -1, 40, -1, -1, -1, -1, -1, 46, -1, + -1, -1, -1, -1, 177, 53, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 194, -1, -1, -1, -1, 199, -1, -1, -1, + -1, -1, 80, 167, -1, -1, -1, -1, 172, -1, + -1, -1, -1, 177, -1, -1, -1, -1, -1, 222, + 223, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 194, -1, -1, -1, 237, 199, -1, -1, -1, -1, + -1, 166, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 177, -1, -1, -1, -1, -1, 222, 223, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 194, + -1, -1, 275, 237, 199, 278, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 292, + -1, -1, 295, -1, -1, -1, -1, 222, 223, 177, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 275, 237, -1, 278, -1, 194, -1, -1, -1, + -1, 199, -1, -1, -1, -1, -1, -1, 292, -1, + -1, 295, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 222, 223, -1, -1, -1, -1, + 275, -1, -1, 278, -1, -1, -1, -1, -1, 237, + -1, -1, -1, -1, -1, -1, -1, 292, -1, -1, + 295, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 394, -1, -1, -1, -1, -1, 275, -1, 324, + 278, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 292, -1, -1, 295, -1, -1, + -1, -1, -1, -1, -1, 8, -1, -1, 11, -1, + 394, -1, 15, 16, 17, 18, 19, 20, 21, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 36, 457, -1, -1, -1, -1, -1, + -1, -1, -1, 46, -1, -1, -1, -1, -1, 394, + 53, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 80, -1, 502, + -1, -1, 505, 506, 507, -1, 509, 510, 511, 512, + 513, 514, -1, -1, -1, -1, 394, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 502, -1, + -1, 505, 506, 507, -1, 509, 510, 511, 512, 513, + 514, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 502, -1, -1, + 505, 506, 507, -1, 509, 510, 511, 512, 513, 514, + -1, -1, -1, -1, 177, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 8, 194, -1, 11, -1, -1, 199, 15, 16, 17, + 18, 19, 20, 21, 502, -1, -1, 505, 506, 507, + -1, 509, 510, 511, 512, 513, 514, -1, 36, 222, + 223, -1, 40, -1, -1, -1, -1, -1, 46, -1, + -1, -1, -1, -1, 237, 53, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 8, -1, -1, 11, + -1, -1, 80, 15, 16, 17, 18, 19, 20, 21, + -1, -1, 275, -1, -1, 278, -1, -1, -1, -1, + -1, -1, -1, -1, 36, -1, -1, -1, -1, 292, + -1, -1, 295, -1, 46, -1, -1, -1, -1, -1, + -1, 53, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 318, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 80, -1, + -1, -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, 19, 20, 21, 177, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 36, -1, -1, 194, 40, -1, -1, + -1, 199, -1, 46, -1, -1, -1, -1, -1, -1, + 53, 394, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 222, 223, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 80, -1, 237, + 172, -1, -1, -1, -1, 177, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 194, -1, -1, -1, -1, 199, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 275, -1, -1, + 278, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 222, 223, -1, -1, 292, -1, -1, 295, -1, -1, + -1, -1, -1, -1, -1, 237, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 502, + -1, -1, 505, 506, 507, -1, 509, 510, 511, 512, + 513, 514, -1, -1, 177, -1, -1, -1, -1, -1, + -1, -1, -1, 275, -1, -1, 278, -1, -1, -1, + -1, 194, -1, -1, -1, -1, 199, -1, -1, -1, + 292, -1, -1, 295, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 8, -1, -1, 11, -1, 222, + 223, 15, 16, 17, 18, 19, 20, 21, -1, -1, + -1, -1, -1, -1, 237, -1, 394, -1, -1, -1, + -1, -1, 36, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 46, -1, -1, -1, -1, -1, -1, 53, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 8, 275, -1, 11, 278, -1, -1, 15, 16, + 17, 18, 19, 20, 21, -1, 80, -1, -1, 292, + -1, -1, 295, -1, -1, -1, -1, -1, -1, 36, + -1, -1, 394, -1, -1, -1, -1, -1, -1, 46, + -1, -1, -1, -1, -1, -1, 53, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 80, 502, -1, -1, 505, 506, 507, + -1, 509, 510, 511, 512, 513, 514, -1, 8, -1, + -1, 11, -1, -1, -1, 15, 16, 17, 18, 19, + 20, 21, -1, 167, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 177, -1, -1, 36, -1, -1, -1, + 40, 394, -1, -1, -1, -1, 46, -1, -1, -1, + 194, -1, -1, 53, -1, 199, -1, -1, -1, -1, + 502, -1, -1, 505, 506, 507, -1, 509, 510, 511, + 512, 513, 514, -1, -1, -1, -1, -1, 222, 223, + 80, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 177, -1, -1, 237, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 194, -1, -1, + -1, -1, 199, -1, -1, -1, -1, 8, -1, -1, + 11, -1, -1, -1, 15, 16, 17, 18, 19, 20, + 21, 275, -1, -1, 278, 222, 223, -1, -1, -1, + -1, -1, -1, -1, -1, 36, -1, -1, 292, 502, + 237, 295, 505, 506, 507, 46, 509, 510, 511, 512, + 513, 514, 53, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 177, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 275, 80, + -1, 278, -1, -1, 194, -1, -1, -1, -1, 199, + -1, -1, -1, -1, -1, 292, -1, -1, 295, -1, + -1, -1, -1, -1, -1, -1, -1, 8, -1, -1, + 11, -1, 222, 223, 15, 16, 17, 18, 19, 20, + 21, -1, -1, -1, -1, -1, -1, 237, -1, -1, + -1, -1, -1, -1, -1, 36, -1, -1, -1, -1, + 394, -1, -1, -1, -1, 46, -1, -1, -1, -1, + -1, -1, 53, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 275, -1, -1, 278, -1, + -1, -1, -1, -1, -1, -1, 177, -1, -1, 80, + -1, -1, 292, -1, -1, 295, -1, -1, -1, -1, + -1, -1, -1, 194, -1, -1, 8, 394, 199, 11, + -1, -1, -1, 15, 16, 17, 18, 19, 20, 21, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 222, 223, -1, 36, -1, -1, -1, -1, -1, + 427, -1, -1, -1, 46, -1, 237, -1, -1, -1, + -1, 53, -1, -1, -1, -1, -1, -1, 502, -1, + -1, 505, 506, 507, -1, 509, 510, 511, 512, 513, + 514, -1, -1, -1, -1, -1, -1, -1, 80, -1, + -1, -1, -1, -1, 275, -1, 177, 278, -1, -1, + -1, -1, -1, -1, 394, -1, -1, -1, -1, -1, + -1, 292, -1, 194, 295, -1, -1, -1, 199, -1, + -1, -1, -1, -1, -1, 502, -1, -1, 505, 506, + 507, -1, 509, 510, 511, 512, 513, 514, -1, -1, + -1, 222, 223, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 237, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 177, -1, -1, -1, -1, + -1, -1, -1, -1, 275, -1, -1, 278, -1, -1, + -1, -1, 194, -1, -1, -1, -1, 199, -1, -1, + -1, 292, 502, 394, 295, 505, 506, 507, -1, 509, + 510, 511, 512, 513, 514, -1, -1, -1, -1, -1, + 222, 223, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 237, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 275, -1, -1, 278, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, - 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 43, 44, -1, 46, 47, 48, - -1, 50, 51, 52, 53, 54, -1, 56, 57, -1, - 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, - 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, - 79, -1, -1, -1, 83, 84, 85, 86, 87, 88, - -1, 90, 91, 92, -1, 94, 95, 96, 97, 98, - 99, -1, -1, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, - -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, - 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, - -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, + 292, -1, -1, 295, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 394, -1, -1, -1, -1, -1, -1, + -1, 502, -1, -1, 505, 506, 507, -1, 509, 510, + 511, 512, 513, 514, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 394, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 502, -1, -1, 505, 506, 507, -1, 509, 510, + 511, 512, 513, 514, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -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, 5, -1, -1, -1, + 502, -1, -1, 505, 506, 507, -1, 509, 510, 511, + 512, 513, 514, 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, 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, -1, 161, -1, 163, 164, 165, 166, -1, 168, - -1, 170, -1, -1, -1, 174, 175, 176, -1, 178, - -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, - 189, 190, 191, 192, 193, -1, 195, 196, 197, 198, - -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, - -1, 210, 211, 212, 213, 214, 215, 216, 217, -1, - 219, -1, 221, -1, -1, 224, -1, 226, 227, 228, - 229, 230, 231, -1, -1, 234, -1, 236, -1, -1, + 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, - -1, 270, 271, 272, 273, 274, -1, 276, 277, -1, - 279, -1, 281, 282, 283, 284, 285, 286, -1, 288, - 289, -1, 291, 292, 293, 294, -1, -1, 297, 298, - 299, -1, 301, -1, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, - 319, 320, 321, -1, 323, 324, 325, 326, 327, 328, - -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, - 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, + 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, -1, 362, 363, -1, 365, 366, 367, 368, + 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, - 379, 380, 381, -1, -1, 384, 385, 386, 387, 388, - 389, 390, 391, 392, -1, -1, 395, 396, 397, 398, - -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, - -1, 420, -1, 422, 423, 424, 425, 426, -1, 428, - 429, 430, -1, -1, 433, 434, 435, 436, 437, -1, - 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, - 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, - 459, 460, 461, 462, 463, 464, 465, -1, 467, -1, - 469, 470, 471, 472, 473, 474, 475, -1, -1, 478, - -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, + 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, 497, 498, - 499, 500, 501, 3, -1, 5, -1, -1, -1, -1, + 499, 500, 501, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, - 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, - 60, 61, 62, 63, 64, -1, -1, 67, 68, 69, - 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, - -1, -1, -1, 83, 84, 85, 86, 87, 88, -1, - 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, - -1, -1, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, - 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, - 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, - 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, + 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, - -1, 161, -1, 163, 164, 165, 166, -1, 168, -1, - 170, -1, -1, -1, 174, 175, 176, -1, 178, -1, - 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, - 190, 191, 192, 193, -1, 195, 196, 197, 198, -1, - 200, 201, 202, 203, 204, 205, 206, -1, 208, -1, - 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, - -1, 221, -1, -1, 224, -1, 226, 227, 228, 229, - 230, 231, -1, -1, 234, -1, 236, -1, -1, 239, + 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, -1, - 270, 271, 272, 273, 274, -1, 276, 277, -1, 279, - -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, - -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, - -1, 301, -1, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, - 320, 321, -1, 323, 324, 325, 326, 327, 328, -1, - 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, - 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, + 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, -1, 362, 363, -1, 365, 366, 367, 368, 369, + 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, - 380, 381, -1, -1, 384, 385, 386, 387, 388, 389, - 390, 391, 392, -1, -1, 395, 396, 397, 398, -1, + 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, -1, -1, 417, 418, -1, - 420, -1, 422, 423, 424, 425, 426, -1, 428, 429, - 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, - 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, - 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, - 460, 461, 462, 463, 464, 465, -1, 467, -1, 469, - 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, - -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 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, 3, -1, 5, -1, -1, -1, -1, -1, + 500, 501, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, - 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, - 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, - 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, - 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, - -1, -1, 83, 84, 85, 86, 87, 88, -1, 90, - 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, - -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, - 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, - 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, - 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, -1, - 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, - -1, -1, -1, 174, 175, 176, -1, 178, -1, 180, - -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, - 191, 192, 193, -1, 195, 196, 197, 198, -1, 200, - 201, 202, 203, 204, 205, 206, -1, 208, -1, 210, - 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, - 221, -1, -1, 224, -1, 226, 227, 228, 229, 230, - 231, -1, -1, 234, -1, 236, -1, -1, 239, 240, + -1, 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, 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, -1, 270, - 271, 272, 273, 274, -1, 276, 277, -1, 279, -1, - 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, - 291, 292, 293, 294, -1, -1, 297, 298, 299, -1, - 301, -1, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, - 321, -1, 323, 324, 325, 326, 327, 328, -1, 330, - 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 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, - -1, 362, 363, -1, 365, 366, 367, 368, 369, 370, + 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, - 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, - 391, 392, -1, -1, 395, 396, 397, 398, -1, 400, + 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, -1, -1, 417, 418, -1, 420, - -1, 422, 423, 424, 425, 426, -1, 428, 429, 430, - -1, -1, 433, 434, 435, 436, 437, -1, 439, 440, - 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, - 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, - 461, 462, 463, 464, 465, -1, 467, -1, 469, 470, - 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, + 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, 3, -1, 5, -1, -1, -1, -1, -1, -1, + 501, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, - 32, 33, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, - 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, - 62, 63, 64, -1, -1, 67, 68, 69, 70, 71, - 72, 73, -1, 75, 76, 77, 78, 79, -1, -1, - -1, 83, 84, 85, 86, 87, 88, -1, 90, 91, - 92, -1, 94, 95, 96, 97, 98, 99, -1, -1, + 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, 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, -1, 118, -1, 120, 121, - 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, - -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, - 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, -1, 161, - -1, 163, 164, 165, 166, -1, 168, -1, 170, -1, - -1, -1, 174, 175, 176, -1, 178, -1, 180, -1, - 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, - 192, 193, -1, 195, 196, 197, 198, -1, 200, 201, - 202, 203, 204, 205, 206, -1, 208, -1, 210, 211, - 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, - -1, -1, 224, -1, 226, 227, 228, 229, 230, 231, - -1, -1, 234, -1, 236, -1, -1, 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, -1, 270, 271, - 272, 273, 274, -1, 276, 277, -1, 279, -1, 281, - 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, - 292, 293, 294, -1, -1, 297, 298, 299, -1, 301, - -1, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, - -1, 323, 324, 325, 326, 327, 328, -1, 330, 331, - 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, - 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, - 362, 363, -1, 365, 366, 367, 368, 369, 370, 371, + 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, - -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, - 392, -1, -1, 395, 396, 397, 398, -1, 400, 401, + 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, -1, -1, 417, 418, 419, 420, -1, - 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, - -1, 433, 434, 435, 436, 437, -1, 439, 440, 441, - 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, - -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, - 462, 463, 464, 465, -1, 467, -1, 469, 470, 471, - 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, + 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, - 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, + 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, - 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, - 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, - 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, - 63, 64, -1, -1, 67, 68, 69, 70, 71, 72, - 73, -1, 75, 76, 77, 78, 79, -1, -1, -1, - 83, 84, 85, 86, 87, 88, -1, 90, 91, 92, - -1, 94, 95, 96, 97, 98, 99, -1, -1, 102, + 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, -1, 118, -1, 120, 121, 122, - 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, - -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, - -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, -1, 161, -1, - 163, 164, 165, 166, -1, 168, -1, 170, -1, -1, - -1, 174, 175, 176, -1, 178, -1, 180, -1, 182, - 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, - 193, -1, 195, 196, 197, 198, -1, 200, 201, 202, - 203, 204, 205, 206, -1, 208, -1, 210, 211, 212, - 213, 214, 215, 216, 217, -1, 219, -1, 221, -1, - -1, 224, -1, 226, 227, 228, 229, 230, 231, -1, - -1, 234, -1, 236, -1, -1, 239, 240, 241, 242, + 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, -1, 270, 271, 272, - 273, 274, -1, 276, 277, -1, 279, -1, 281, 282, - 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, - 293, 294, -1, -1, 297, 298, 299, -1, 301, -1, + 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, -1, -1, -1, -1, 319, 320, 321, -1, - 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, - 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, - 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, - 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, - 363, -1, 365, 366, 367, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, - -1, 384, 385, 386, 387, 388, 389, 390, 391, 392, - -1, -1, 395, 396, 397, 398, -1, 400, 401, 402, + 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, -1, -1, 417, 418, -1, 420, -1, 422, - 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, - 433, 434, 435, 436, 437, -1, 439, 440, 441, 442, - 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, - 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, - 463, 464, 465, -1, 467, -1, 469, 470, 471, 472, - 473, 474, 475, -1, -1, 478, -1, -1, 481, 482, + 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, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, - 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, - 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, + -1, -1, -1, 37, -1, -1, -1, -1, 42, 43, + 44, -1, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, 71, 72, 73, - -1, 75, 76, 77, 78, 79, -1, -1, -1, 83, - 84, 85, 86, 87, 88, -1, 90, 91, 92, -1, - 94, 95, 96, 97, 98, 99, -1, -1, 102, 103, + -1, 75, 76, 77, 78, 79, -1, 81, -1, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, -1, + 94, 95, 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, -1, 161, -1, 163, - 164, 165, 166, -1, 168, -1, 170, -1, -1, -1, - 174, 175, 176, -1, 178, -1, 180, -1, 182, 183, + 154, 155, 156, 157, 158, 159, 160, 161, -1, 163, + 164, 165, 166, -1, 168, -1, 170, 171, -1, 173, + 174, 175, 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, - -1, 195, 196, 197, 198, -1, 200, 201, 202, 203, - 204, 205, 206, -1, 208, -1, 210, 211, 212, 213, - 214, 215, 216, 217, -1, 219, -1, 221, -1, -1, - 224, -1, 226, 227, 228, 229, 230, 231, -1, -1, - 234, -1, 236, -1, -1, 239, 240, 241, 242, 243, + 194, 195, 196, 197, 198, -1, 200, 201, 202, 203, + 204, 205, 206, -1, 208, 209, 210, 211, 212, 213, + 214, 215, 216, 217, -1, 219, -1, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, -1, -1, + 234, 235, 236, 237, -1, 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, -1, 270, 271, 272, 273, - 274, -1, 276, 277, -1, 279, -1, 281, 282, 283, - 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, - 294, -1, -1, 297, 298, 299, -1, 301, -1, 303, + 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, + 274, -1, 276, 277, 278, 279, -1, 281, 282, 283, + 284, 285, 286, -1, 288, 289, 290, -1, 292, 293, + 294, -1, -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, -1, -1, -1, -1, 319, 320, 321, -1, 323, + 314, -1, -1, -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, - -1, 365, 366, 367, 368, 369, 370, 371, 372, 373, - 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, + 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 375, 376, 377, 378, 379, 380, 381, -1, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, - -1, 395, 396, 397, 398, -1, 400, 401, 402, 403, + 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, - 414, -1, -1, 417, 418, -1, 420, -1, 422, 423, + 414, -1, -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, - 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, + 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, - 464, 465, -1, 467, -1, 469, 470, 471, 472, 473, + 464, 465, -1, 467, 468, 469, 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, - -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, - -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, + 25, 26, 27, 28, 29, -1, 31, 32, 33, 34, + 35, -1, 37, -1, -1, -1, -1, 42, 43, 44, + -1, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, 71, 72, 73, -1, - 75, 76, 77, 78, 79, -1, -1, -1, 83, 84, - 85, 86, 87, 88, -1, 90, 91, 92, -1, 94, - 95, 96, 97, 98, 99, -1, -1, 102, 103, 104, + 75, 76, 77, 78, 79, -1, 81, -1, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, -1, 94, + 95, 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, -1, 161, -1, 163, 164, - 165, 166, -1, 168, -1, 170, -1, -1, -1, 174, - 175, 176, -1, 178, -1, 180, -1, 182, 183, 184, - 185, -1, 187, 188, 189, 190, 191, 192, 193, -1, + 165, 166, -1, 168, -1, 170, 171, -1, 173, 174, + 175, 176, 177, 178, -1, 180, -1, 182, 183, 184, + 185, -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, - 205, 206, -1, 208, -1, 210, 211, 212, 213, 214, - 215, 216, 217, -1, 219, -1, 221, -1, -1, 224, - -1, 226, 227, 228, 229, 230, 231, -1, -1, 234, - -1, 236, -1, -1, 239, 240, 241, 242, 243, 244, + 205, 206, -1, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, -1, 219, -1, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, -1, -1, 234, + 235, 236, 237, -1, 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, -1, 270, 271, 272, 273, 274, - -1, 276, 277, -1, 279, -1, 281, 282, 283, 284, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + -1, 276, 277, 278, 279, -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, - -1, -1, 297, 298, 299, -1, 301, -1, 303, 304, + -1, -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - -1, -1, -1, -1, 319, 320, 321, -1, 323, 324, + -1, -1, -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, - 355, 356, 357, 358, 359, 360, -1, 362, 363, -1, + 355, 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, - 385, 386, 387, 388, 389, 390, 391, 392, -1, -1, + 375, 376, 377, 378, 379, 380, 381, -1, 383, 384, + 385, 386, 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, - -1, -1, 417, 418, -1, 420, -1, 422, 423, 424, + -1, -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, - 465, -1, 467, -1, 469, 470, 471, 472, 473, 474, + 465, -1, 467, 468, 469, 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 499, 500, 501, 3, -1, 5, + 495, 496, 497, 498, 499, 500, 501, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, - 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, + -1, -1, -1, -1, -1, -1, 42, 43, 44, -1, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, - -1, 67, 68, 69, 70, 71, 72, 73, -1, 75, - 76, 77, 78, 79, -1, -1, -1, 83, 84, 85, - 86, 87, 88, -1, 90, 91, 92, -1, 94, 95, - 96, 97, 98, 99, -1, -1, 102, 103, 104, 105, + 66, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, 81, -1, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, -1, 161, -1, 163, 164, 165, - 166, -1, 168, -1, 170, -1, -1, -1, 174, 175, - 176, -1, 178, -1, 180, -1, 182, 183, 184, 185, - -1, 187, 188, 189, 190, 191, 192, 193, -1, 195, + 166, -1, 168, -1, 170, 171, -1, 173, 174, 175, + 176, 177, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, - 206, -1, 208, -1, 210, 211, 212, 213, 214, 215, - 216, 217, -1, 219, -1, 221, -1, -1, 224, -1, - 226, 227, 228, 229, 230, 231, -1, -1, 234, -1, - 236, -1, -1, 239, 240, 241, 242, 243, 244, 245, + 206, -1, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, -1, -1, 234, 235, + 236, 237, -1, 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, -1, 270, 271, 272, 273, 274, -1, - 276, 277, -1, 279, -1, 281, 282, 283, 284, 285, + 266, 267, 268, 269, 270, 271, 272, 273, 274, -1, + 276, 277, 278, 279, -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, - -1, 297, 298, 299, -1, 301, -1, 303, 304, 305, + -1, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, - -1, -1, -1, 319, 320, 321, -1, 323, 324, 325, + -1, -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, -1, 362, 363, -1, 365, + 356, 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, - 386, 387, 388, 389, 390, 391, 392, -1, -1, 395, + 386, 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, - -1, 417, 418, -1, 420, -1, 422, 423, 424, 425, + -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, 465, - -1, 467, -1, 469, 470, 471, 472, 473, 474, 475, + -1, 467, 468, 469, 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, - 496, 497, 498, 499, 500, 501, 3, -1, 5, -1, + 496, 497, 498, 499, 500, 501, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, - 47, 48, -1, 50, 51, 52, 53, 54, -1, 56, + -1, -1, -1, -1, -1, 42, 43, 44, -1, 46, + 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, -1, -1, 83, 84, 85, 86, - 87, 88, -1, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, -1, 102, 103, 104, 105, 106, + 77, 78, 79, -1, 81, -1, 83, 84, 85, 86, + 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, + 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, -1, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, -1, -1, -1, 174, 175, 176, - -1, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, -1, 195, 196, + -1, 168, -1, 170, 171, -1, 173, 174, 175, 176, + 177, 178, -1, 180, -1, 182, 183, 184, 185, -1, + 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, -1, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, -1, -1, 224, -1, 226, - 227, 228, 229, 230, 231, -1, -1, 234, -1, 236, - -1, -1, 239, 240, 241, 242, 243, 244, 245, 246, + -1, 208, 209, 210, 211, 212, 213, 214, 215, 216, + 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, + 237, -1, 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, -1, 270, 271, 272, 273, 274, -1, 276, - 277, -1, 279, -1, 281, 282, 283, 284, 285, 286, + 267, 268, 269, 270, 271, 272, 273, 274, -1, 276, + 277, 278, 279, -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, -1, 301, -1, 303, 304, 305, 306, + 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, -1, 323, 324, 325, 326, + -1, -1, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, -1, 365, 366, + 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, -1, 395, 396, + 387, 388, 389, 390, 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, -1, 422, 423, 424, 425, 426, + 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, - 467, -1, 469, 470, 471, 472, 473, 474, 475, -1, + 467, 468, 469, 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, 3, -1, 5, -1, -1, + 497, 498, 499, 500, 501, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, - 68, 69, 70, 71, 72, 73, -1, 75, 76, 77, - 78, 79, -1, -1, -1, 83, 84, 85, 86, 87, - 88, -1, 90, 91, 92, -1, 94, 95, 96, 97, + 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, -1, -1, 82, 83, 84, 85, 86, 87, + 88, -1, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, -1, -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, @@ -17822,7 +17108,7 @@ static const yytype_int16 yycheck[] = 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, -1, 161, -1, 163, 164, 165, 166, -1, - 168, -1, 170, -1, -1, -1, 174, 175, 176, -1, + 168, 169, 170, -1, -1, -1, 174, 175, 176, -1, 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, -1, 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, -1, @@ -17838,7 +17124,7 @@ static const yytype_int16 yycheck[] = 298, 299, -1, 301, -1, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, -1, 323, 324, 325, 326, 327, - 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, + 328, 329, 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, -1, 365, 366, 367, @@ -17850,21 +17136,21 @@ static const yytype_int16 yycheck[] = 418, -1, 420, -1, 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, 444, 445, 446, -1, - -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, + 448, 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, 467, -1, 469, 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 498, 499, 500, 501, 3, -1, 5, -1, -1, -1, + 498, 499, 500, 501, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, - 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, -1, -1, -1, 83, 84, 85, 86, 87, 88, - -1, 90, 91, 92, -1, 94, 95, 96, 97, 98, + -1, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, -1, -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, @@ -17872,13 +17158,13 @@ static const yytype_int16 yycheck[] = -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, -1, 161, -1, 163, 164, 165, 166, -1, 168, - -1, 170, -1, -1, -1, 174, 175, 176, -1, 178, + 169, 170, -1, -1, -1, 174, 175, 176, -1, 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, -1, 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, -1, -1, 224, -1, 226, 227, 228, - 229, 230, 231, -1, -1, 234, -1, 236, -1, -1, + 229, 230, 231, -1, -1, 234, -1, 236, 237, -1, 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, @@ -17888,7 +17174,7 @@ static const yytype_int16 yycheck[] = 299, -1, 301, -1, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, -1, 323, 324, 325, 326, 327, 328, - -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, + 329, 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, -1, 365, 366, 367, 368, @@ -17899,7 +17185,7 @@ static const yytype_int16 yycheck[] = 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, -1, 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, -1, - 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, + 439, 440, 441, 442, 443, 444, 445, 446, -1, 448, 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, 467, -1, 469, 470, 471, 472, 473, 474, 475, -1, -1, 478, @@ -17908,7 +17194,7 @@ static const yytype_int16 yycheck[] = 499, 500, 501, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, - -1, 31, 32, 33, -1, -1, -1, -1, -1, -1, + -1, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, 69, @@ -17957,7 +17243,7 @@ static const yytype_int16 yycheck[] = 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, + -1, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, @@ -18033,7 +17319,7 @@ static const yytype_int16 yycheck[] = 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, -1, 270, 271, 272, 273, 274, -1, 276, 277, -1, 279, -1, 281, - 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, + 282, 283, 284, 285, 286, -1, 288, 289, -1, 291, 292, 293, 294, -1, -1, 297, 298, 299, -1, 301, -1, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, @@ -18055,10 +17341,10 @@ static const yytype_int16 yycheck[] = 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, - 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, - 33, -1, -1, -1, -1, -1, -1, 40, -1, -1, + 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, 71, 72, @@ -18083,7 +17369,7 @@ static const yytype_int16 yycheck[] = 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, -1, 270, 271, 272, 273, 274, -1, 276, 277, -1, 279, -1, 281, 282, - 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, + 283, 284, 285, 286, -1, 288, 289, -1, 291, 292, 293, 294, -1, -1, 297, 298, 299, -1, 301, -1, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, -1, @@ -18105,10 +17391,10 @@ static const yytype_int16 yycheck[] = 473, 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 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, 22, 23, - 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, - -1, -1, -1, -1, -1, -1, 40, -1, -1, 43, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, 71, 72, 73, @@ -18155,9 +17441,9 @@ static const yytype_int16 yycheck[] = 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 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, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, -1, + 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, @@ -18183,7 +17469,7 @@ static const yytype_int16 yycheck[] = 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, -1, 270, 271, 272, 273, 274, -1, 276, 277, -1, 279, -1, 281, 282, 283, 284, - 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, + 285, 286, -1, 288, 289, -1, 291, 292, 293, 294, -1, -1, 297, 298, 299, -1, 301, -1, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, -1, 323, 324, @@ -18246,7 +17532,7 @@ static const yytype_int16 yycheck[] = 386, 387, 388, 389, 390, 391, 392, -1, -1, 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, - -1, 417, 418, -1, 420, -1, 422, 423, 424, 425, + -1, 417, 418, 419, 420, -1, 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, @@ -18354,10 +17640,10 @@ static const yytype_int16 yycheck[] = -1, 469, 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, - 498, 499, 500, 501, 3, -1, 5, -1, -1, -1, + 498, 499, 500, 501, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, - 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, + 29, 30, 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, @@ -18454,59 +17740,310 @@ static const yytype_int16 yycheck[] = 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, - 500, 501, 3, -1, -1, -1, -1, -1, -1, -1, + 500, 501, 3, -1, 5, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, + 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, + 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, + 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, + 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, + -1, -1, 83, 84, 85, 86, 87, 88, -1, 90, + 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, + -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, + 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, + 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, + 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, -1, + 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, + -1, -1, -1, 174, 175, 176, -1, 178, -1, 180, + -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, + 191, 192, 193, -1, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, -1, 210, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, -1, -1, 224, -1, 226, 227, 228, 229, 230, + 231, -1, -1, 234, -1, 236, -1, -1, 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, -1, 270, + 271, 272, 273, 274, -1, 276, 277, -1, 279, -1, + 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, + -1, 292, 293, 294, -1, -1, 297, 298, 299, -1, + 301, -1, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, + 321, -1, 323, 324, 325, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, -1, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, + 391, 392, -1, -1, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, + -1, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, 435, 436, 437, -1, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, 463, 464, 465, -1, 467, -1, 469, 470, + 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + 501, 3, -1, 5, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, + 32, 33, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, + 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, + 62, 63, 64, -1, -1, 67, 68, 69, 70, 71, + 72, 73, -1, 75, 76, 77, 78, 79, -1, -1, + -1, 83, 84, 85, 86, 87, 88, -1, 90, 91, + 92, -1, 94, 95, 96, 97, 98, 99, -1, -1, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, + 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, + -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, + 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, -1, 161, + -1, 163, 164, 165, 166, -1, 168, -1, 170, -1, + -1, -1, 174, 175, 176, -1, 178, -1, 180, -1, + 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, + 192, 193, -1, 195, 196, 197, 198, -1, 200, 201, + 202, 203, 204, 205, 206, -1, 208, -1, 210, 211, + 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, + -1, -1, 224, -1, 226, 227, 228, 229, 230, 231, + -1, -1, 234, -1, 236, -1, -1, 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, -1, 270, 271, + 272, 273, 274, -1, 276, 277, -1, 279, -1, 281, + 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, + 292, 293, 294, -1, -1, 297, 298, 299, -1, 301, + -1, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, + -1, 323, 324, 325, 326, 327, 328, -1, 330, 331, + 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, + 362, 363, -1, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, + -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, + 392, -1, -1, 395, 396, 397, 398, -1, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, -1, -1, 417, 418, -1, 420, -1, + 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, + -1, 433, 434, 435, 436, 437, -1, 439, 440, 441, + 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, + -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, + 462, 463, 464, 465, -1, 467, -1, 469, 470, 471, + 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, + 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, + 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, + 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, + 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, + 63, 64, -1, -1, 67, 68, 69, 70, 71, 72, + 73, -1, 75, 76, 77, 78, 79, -1, -1, -1, + 83, 84, 85, 86, 87, 88, -1, 90, 91, 92, + -1, 94, 95, 96, 97, 98, 99, -1, -1, 102, + 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, + 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, + 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, + -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, + -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, + 153, 154, 155, 156, 157, 158, 159, -1, 161, -1, + 163, 164, 165, 166, -1, 168, -1, 170, -1, -1, + -1, 174, 175, 176, -1, 178, -1, 180, -1, 182, + 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, + 193, -1, 195, 196, 197, 198, -1, 200, 201, 202, + 203, 204, 205, 206, -1, 208, -1, 210, 211, 212, + 213, 214, 215, 216, 217, -1, 219, -1, 221, -1, + -1, 224, -1, 226, 227, 228, 229, 230, 231, -1, + -1, 234, -1, 236, -1, -1, 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, -1, 270, 271, 272, + 273, 274, -1, 276, 277, -1, 279, -1, 281, 282, + 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, + 293, 294, -1, -1, 297, 298, 299, -1, 301, -1, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, -1, -1, -1, -1, 319, 320, 321, -1, + 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, + 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, + 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, + 363, -1, 365, 366, 367, 368, 369, 370, 371, 372, + 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, + -1, 384, 385, 386, 387, 388, 389, 390, 391, 392, + -1, -1, 395, 396, 397, 398, -1, 400, 401, 402, + 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, + 413, 414, -1, -1, 417, 418, -1, 420, -1, 422, + 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, + 433, 434, 435, 436, 437, -1, 439, 440, 441, 442, + 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, + 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, + 463, 464, 465, -1, 467, -1, 469, 470, 471, 472, + 473, 474, 475, -1, -1, 478, -1, -1, 481, 482, + 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, + 493, 494, 495, 496, 497, 498, 499, 500, 501, 3, + -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, + 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, + 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, + 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, + 64, -1, -1, 67, 68, 69, 70, 71, 72, 73, + -1, 75, 76, 77, 78, 79, -1, -1, -1, 83, + 84, 85, 86, 87, 88, -1, 90, 91, 92, -1, + 94, 95, 96, 97, 98, 99, -1, -1, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, + 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, + 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, + 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, -1, 161, -1, 163, + 164, 165, 166, -1, 168, -1, 170, -1, -1, -1, + 174, 175, 176, -1, 178, -1, 180, -1, 182, 183, + 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, + -1, 195, 196, 197, 198, -1, 200, 201, 202, 203, + 204, 205, 206, -1, 208, -1, 210, 211, 212, 213, + 214, 215, 216, 217, -1, 219, -1, 221, -1, -1, + 224, -1, 226, 227, 228, 229, 230, 231, -1, -1, + 234, -1, 236, -1, -1, 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, -1, 270, 271, 272, 273, + 274, -1, 276, 277, -1, 279, -1, 281, 282, 283, + 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, + 294, -1, -1, 297, 298, 299, -1, 301, -1, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, -1, -1, -1, -1, 319, 320, 321, -1, 323, + 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, + 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, + 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, + -1, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, + 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, + -1, 395, 396, 397, 398, -1, 400, 401, 402, 403, + 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, + 414, -1, -1, 417, 418, -1, 420, -1, 422, 423, + 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, + 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, + 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, + 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, + 464, 465, -1, 467, -1, 469, 470, 471, 472, 473, + 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, + 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 499, 500, 501, 3, -1, + 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, + 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, + -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, + -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, + -1, -1, 67, 68, 69, 70, 71, 72, 73, -1, + 75, 76, 77, 78, 79, -1, -1, -1, 83, 84, + 85, 86, 87, 88, -1, 90, 91, 92, -1, 94, + 95, 96, 97, 98, 99, -1, -1, 102, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, + 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, + 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, + 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, + 145, 146, -1, 148, 149, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, -1, 161, -1, 163, 164, + 165, 166, -1, 168, -1, 170, -1, -1, -1, 174, + 175, 176, -1, 178, -1, 180, -1, 182, 183, 184, + 185, -1, 187, 188, 189, 190, 191, 192, 193, -1, + 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, + 205, 206, -1, 208, -1, 210, 211, 212, 213, 214, + 215, 216, 217, -1, 219, -1, 221, -1, -1, 224, + -1, 226, 227, 228, 229, 230, 231, -1, -1, 234, + -1, 236, -1, -1, 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, -1, 270, 271, 272, 273, 274, + -1, 276, 277, -1, 279, -1, 281, 282, 283, 284, + 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, + -1, -1, 297, 298, 299, -1, 301, -1, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + -1, -1, -1, -1, 319, 320, 321, -1, 323, 324, + 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, + 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, + 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, -1, 362, 363, -1, + 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, + 375, 376, 377, 378, 379, 380, 381, -1, -1, 384, + 385, 386, 387, 388, 389, 390, 391, 392, -1, -1, + 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + -1, -1, 417, 418, -1, 420, -1, 422, 423, 424, + 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, + 435, 436, 437, -1, 439, 440, 441, 442, 443, 444, + 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, + 455, 456, -1, 458, 459, 460, 461, 462, 463, 464, + 465, -1, 467, -1, 469, 470, 471, 472, 473, 474, + 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, + 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, + 495, 496, 497, 498, 499, 500, 501, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, - 31, 32, 33, -1, -1, -1, 37, -1, -1, 40, - -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, - 51, 52, -1, 54, 55, 56, 57, -1, 59, 60, - 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, - 71, 72, 73, -1, 75, 76, 77, 78, -1, -1, - 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, - 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, - 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, - 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, - 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, - 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, - 151, -1, 153, 154, 155, 156, 157, 158, -1, -1, - 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, - 171, -1, 173, 174, 175, 176, 177, 178, -1, 180, - -1, -1, -1, 184, 185, -1, 187, 188, 189, 190, - 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, - 201, 202, 203, 204, 205, 206, -1, 208, 209, -1, - 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, - 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, - 231, -1, -1, 234, 235, 236, 237, -1, 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, -1, 276, 277, 278, 279, -1, - -1, 282, 283, 284, 285, 286, -1, 288, 289, -1, - -1, 292, 293, 294, -1, -1, 297, 298, -1, 300, - 301, 302, -1, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, - -1, 322, 323, 324, -1, 326, 327, 328, -1, 330, - 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, - 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - -1, 362, 363, 364, 365, 366, 367, 368, 369, 370, - 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, - 381, -1, 383, 384, 385, 386, 387, 388, 389, 390, - 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, - 411, 412, 413, -1, -1, -1, 417, 418, -1, 420, - 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, - -1, -1, 433, 434, -1, 436, -1, -1, 439, 440, - 441, 442, 443, 444, 445, 446, 447, -1, 449, 450, - 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, - 461, 462, -1, 464, 465, -1, 467, 468, 469, 470, - 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, - 481, 482, 483, 484, 485, 486, 3, -1, 5, -1, - -1, -1, -1, -1, -1, -1, -1, 498, 499, 500, - 501, -1, -1, -1, -1, 22, 23, 24, 25, 26, + -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, + 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, + 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, + 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, + -1, 67, 68, 69, 70, 71, 72, 73, -1, 75, + 76, 77, 78, 79, -1, -1, -1, 83, 84, 85, + 86, 87, 88, -1, 90, 91, 92, -1, 94, 95, + 96, 97, 98, 99, -1, -1, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, + -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, + 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, + 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, -1, 161, -1, 163, 164, 165, + 166, -1, 168, -1, 170, -1, -1, -1, 174, 175, + 176, -1, 178, -1, 180, -1, 182, 183, 184, 185, + -1, 187, 188, 189, 190, 191, 192, 193, -1, 195, + 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, + 206, -1, 208, -1, 210, 211, 212, 213, 214, 215, + 216, 217, -1, 219, -1, 221, -1, -1, 224, -1, + 226, 227, 228, 229, 230, 231, -1, -1, 234, -1, + 236, -1, -1, 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, -1, 270, 271, 272, 273, 274, -1, + 276, 277, -1, 279, -1, 281, 282, 283, 284, 285, + 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, + -1, 297, 298, 299, -1, 301, -1, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, -1, + -1, -1, -1, 319, 320, 321, -1, 323, 324, 325, + 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, + -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, + 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, + 356, 357, 358, 359, 360, -1, 362, 363, -1, 365, + 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, + 386, 387, 388, 389, 390, 391, 392, -1, -1, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, + -1, 417, 418, -1, 420, -1, 422, 423, 424, 425, + 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, + 436, 437, -1, 439, 440, 441, 442, 443, 444, 445, + 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, + 456, -1, 458, 459, 460, 461, 462, 463, 464, 465, + -1, 467, -1, 469, 470, 471, 472, 473, 474, 475, + -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, + 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 501, 3, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, + -1, -1, -1, 40, -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, @@ -18556,7 +18093,7 @@ static const yytype_int16 yycheck[] = -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 43, 44, -1, 46, 47, + -1, -1, 40, -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, 77, @@ -18605,7 +18142,7 @@ static const yytype_int16 yycheck[] = 498, 499, 500, 501, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, - 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, + 29, 30, 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, @@ -18652,7 +18189,7 @@ static const yytype_int16 yycheck[] = 469, 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, - 499, 500, 501, 3, -1, -1, -1, -1, -1, -1, + 499, 500, 501, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, -1, @@ -18702,8 +18239,256 @@ static const yytype_int16 yycheck[] = 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, - 500, 501, 3, -1, -1, -1, -1, -1, -1, -1, + 500, 501, 3, -1, 5, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, + 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, + 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, + 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, + 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, + -1, -1, 83, 84, 85, 86, 87, 88, -1, 90, + 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, + -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, + 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, + 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, + 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, -1, + 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, + -1, -1, -1, 174, 175, 176, -1, 178, -1, 180, + -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, + 191, 192, 193, -1, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, -1, 210, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, -1, -1, 224, -1, 226, 227, 228, 229, 230, + 231, -1, -1, 234, -1, 236, -1, -1, 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, -1, 270, + 271, 272, 273, 274, -1, 276, 277, -1, 279, -1, + 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, + -1, 292, 293, 294, -1, -1, 297, 298, 299, -1, + 301, -1, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, + 321, -1, 323, 324, 325, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, -1, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, + 391, 392, -1, -1, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, + -1, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, 435, 436, 437, -1, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, 463, 464, 465, -1, 467, -1, 469, 470, + 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + 501, 3, -1, 5, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, + 32, 33, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, + 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, + 62, 63, 64, -1, -1, 67, 68, 69, 70, 71, + 72, 73, -1, 75, 76, 77, 78, 79, -1, -1, + -1, 83, 84, 85, 86, 87, 88, -1, 90, 91, + 92, -1, 94, 95, 96, 97, 98, 99, -1, -1, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, + 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, + -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, + 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, -1, 161, + -1, 163, 164, 165, 166, -1, 168, -1, 170, -1, + -1, -1, 174, 175, 176, -1, 178, -1, 180, -1, + 182, 183, 184, 185, -1, 187, 188, 189, 190, 191, + 192, 193, -1, 195, 196, 197, 198, -1, 200, 201, + 202, 203, 204, 205, 206, -1, 208, -1, 210, 211, + 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, + -1, -1, 224, -1, 226, 227, 228, 229, 230, 231, + -1, -1, 234, -1, 236, -1, -1, 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, -1, 270, 271, + 272, 273, 274, -1, 276, 277, -1, 279, -1, 281, + 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, + 292, 293, 294, -1, -1, 297, 298, 299, -1, 301, + -1, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, -1, -1, -1, -1, 319, 320, 321, + -1, 323, 324, 325, 326, 327, 328, -1, 330, 331, + 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, + 362, 363, -1, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, + -1, -1, 384, 385, 386, 387, 388, 389, 390, 391, + 392, -1, -1, 395, 396, 397, 398, -1, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, 414, -1, -1, 417, 418, -1, 420, -1, + 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, + -1, 433, 434, 435, 436, 437, -1, 439, 440, 441, + 442, 443, 444, 445, 446, -1, -1, 449, 450, 451, + -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, + 462, 463, 464, 465, -1, 467, -1, 469, 470, 471, + 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, + 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, + 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, + 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, + 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, + 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, + 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, + 63, 64, -1, -1, 67, 68, 69, 70, 71, 72, + 73, -1, 75, 76, 77, 78, 79, -1, -1, -1, + 83, 84, 85, 86, 87, 88, -1, 90, 91, 92, + -1, 94, 95, 96, 97, 98, 99, -1, -1, 102, + 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, + 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, + 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, + -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, + -1, 144, 145, 146, -1, 148, 149, 150, 151, 152, + 153, 154, 155, 156, 157, 158, 159, -1, 161, -1, + 163, 164, 165, 166, -1, 168, -1, 170, -1, -1, + -1, 174, 175, 176, -1, 178, -1, 180, -1, 182, + 183, 184, 185, -1, 187, 188, 189, 190, 191, 192, + 193, -1, 195, 196, 197, 198, -1, 200, 201, 202, + 203, 204, 205, 206, -1, 208, -1, 210, 211, 212, + 213, 214, 215, 216, 217, -1, 219, -1, 221, -1, + -1, 224, -1, 226, 227, 228, 229, 230, 231, -1, + -1, 234, -1, 236, -1, -1, 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, -1, 270, 271, 272, + 273, 274, -1, 276, 277, -1, 279, -1, 281, 282, + 283, 284, 285, 286, -1, 288, 289, -1, -1, 292, + 293, 294, -1, -1, 297, 298, 299, -1, 301, -1, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, -1, -1, -1, -1, 319, 320, 321, -1, + 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, + 333, 334, 335, -1, 337, 338, 339, 340, 341, 342, + 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, + 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, + 363, -1, 365, 366, 367, 368, 369, 370, 371, 372, + 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, + -1, 384, 385, 386, 387, 388, 389, 390, 391, 392, + -1, -1, 395, 396, 397, 398, -1, 400, 401, 402, + 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, + 413, 414, -1, -1, 417, 418, -1, 420, -1, 422, + 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, + 433, 434, 435, 436, 437, -1, 439, 440, 441, 442, + 443, 444, 445, 446, -1, -1, 449, 450, 451, -1, + 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, + 463, 464, 465, -1, 467, -1, 469, 470, 471, 472, + 473, 474, 475, -1, -1, 478, -1, -1, 481, 482, + 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, + 493, 494, 495, 496, 497, 498, 499, 500, 501, 3, + -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, + 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, + 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, + 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, + 64, -1, -1, 67, 68, 69, 70, 71, 72, 73, + -1, 75, 76, 77, 78, 79, -1, -1, -1, 83, + 84, 85, 86, 87, 88, -1, 90, 91, 92, -1, + 94, 95, 96, 97, 98, 99, -1, -1, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, + 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, + 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, + 144, 145, 146, -1, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, -1, 161, -1, 163, + 164, 165, 166, -1, 168, -1, 170, -1, -1, -1, + 174, 175, 176, -1, 178, -1, 180, -1, 182, 183, + 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, + -1, 195, 196, 197, 198, -1, 200, 201, 202, 203, + 204, 205, 206, -1, 208, -1, 210, 211, 212, 213, + 214, 215, 216, 217, -1, 219, -1, 221, -1, -1, + 224, -1, 226, 227, 228, 229, 230, 231, -1, -1, + 234, -1, 236, -1, -1, 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, -1, 270, 271, 272, 273, + 274, -1, 276, 277, -1, 279, -1, 281, 282, 283, + 284, 285, 286, -1, 288, 289, -1, -1, 292, 293, + 294, -1, -1, 297, 298, 299, -1, 301, -1, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, -1, -1, -1, -1, 319, 320, 321, -1, 323, + 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, + 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, + 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, + 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, + -1, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, + 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, + -1, 395, 396, 397, 398, -1, 400, 401, 402, 403, + 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, + 414, -1, -1, 417, 418, -1, 420, -1, 422, 423, + 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, + 434, 435, 436, 437, -1, 439, 440, 441, 442, 443, + 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, + 454, 455, 456, -1, 458, 459, 460, 461, 462, 463, + 464, 465, -1, 467, -1, 469, 470, 471, 472, 473, + 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, + 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, + 494, 495, 496, 497, 498, 499, 500, 501, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, + 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, + -1, -1, 37, -1, -1, 40, -1, 42, 43, 44, + -1, 46, 47, 48, 49, 50, 51, 52, -1, 54, + 55, 56, 57, -1, 59, 60, 61, 62, 63, 64, + -1, -1, 67, 68, 69, 70, 71, 72, 73, -1, + 75, 76, 77, 78, -1, -1, 81, -1, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, -1, 94, + 95, 96, 97, 98, 99, -1, 101, 102, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, + 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, + 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, + 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, + 145, 146, -1, 148, 149, 150, 151, -1, 153, 154, + 155, 156, 157, 158, -1, -1, 161, -1, 163, 164, + 165, 166, -1, 168, -1, 170, 171, -1, 173, 174, + 175, 176, 177, 178, -1, 180, -1, -1, -1, 184, + 185, -1, 187, 188, 189, 190, 191, 192, 193, 194, + 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, + 205, 206, -1, 208, 209, -1, 211, 212, 213, 214, + 215, 216, 217, -1, 219, -1, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, -1, -1, 234, + 235, 236, 237, -1, 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, + -1, 276, 277, 278, 279, -1, -1, 282, 283, 284, + 285, 286, -1, 288, 289, -1, -1, 292, 293, 294, + -1, -1, 297, 298, -1, 300, 301, 302, -1, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + -1, -1, -1, -1, 319, 320, -1, 322, 323, 324, + -1, 326, 327, 328, -1, 330, 331, 332, 333, 334, + 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, + 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, + 355, 356, 357, 358, 359, 360, -1, 362, 363, 364, + 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, + 375, 376, 377, 378, 379, 380, 381, -1, 383, 384, + 385, 386, 387, 388, 389, 390, 391, 392, -1, 394, + 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, -1, + -1, -1, 417, 418, -1, 420, 421, 422, 423, 424, + 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, + -1, 436, -1, -1, 439, 440, 441, 442, 443, 444, + 445, 446, 447, -1, 449, 450, 451, -1, 453, 454, + 455, 456, -1, 458, 459, 460, 461, 462, -1, 464, + 465, -1, 467, 468, 469, 470, 471, 472, 473, 474, + 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, + 485, 486, 3, -1, 5, -1, -1, -1, -1, -1, + -1, -1, -1, 498, 499, 500, 501, -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, @@ -18855,7 +18640,7 @@ static const yytype_int16 yycheck[] = -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, - -1, -1, -1, -1, -1, -1, 40, -1, -1, 43, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, 71, 72, 73, @@ -18890,7 +18675,7 @@ static const yytype_int16 yycheck[] = 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, -1, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, -1, - 384, 385, 386, 387, 388, -1, 390, 391, 392, -1, + 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, -1, 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, -1, 422, 423, @@ -19003,56 +18788,304 @@ static const yytype_int16 yycheck[] = 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, - 47, 48, -1, 50, 51, 52, 53, 54, -1, 56, - 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, 79, -1, -1, -1, 83, 84, 85, 86, - 87, 88, -1, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, -1, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, -1, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, -1, -1, -1, 174, 175, 176, - -1, 178, -1, 180, -1, 182, 183, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, -1, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, -1, 210, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, -1, -1, 224, -1, 226, - 227, 228, 229, 230, 231, -1, -1, 234, -1, 236, - -1, -1, 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, -1, 270, 271, 272, 273, 274, -1, 276, - 277, -1, 279, -1, 281, 282, 283, 284, 285, 286, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, 299, -1, 301, -1, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, 321, -1, 323, 324, 325, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, -1, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, - 387, 388, 389, 390, 391, 392, -1, -1, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, - 417, 418, -1, 420, -1, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, - 437, -1, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, - 467, -1, 469, 470, 471, 472, 473, 474, 475, -1, - -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, 3, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, + 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 43, 44, -1, 46, + 47, 48, -1, 50, 51, 52, 53, 54, -1, 56, + 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, + 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, + 77, 78, 79, -1, -1, -1, 83, 84, 85, 86, + 87, 88, -1, 90, 91, 92, -1, 94, 95, 96, + 97, 98, 99, -1, -1, 102, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, + -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, + -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, + 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, + -1, 148, 149, 150, 151, 152, 153, 154, 155, 156, + 157, 158, 159, -1, 161, -1, 163, 164, 165, 166, + -1, 168, -1, 170, -1, -1, -1, 174, 175, 176, + -1, 178, -1, 180, -1, 182, 183, 184, 185, -1, + 187, 188, 189, 190, 191, 192, 193, -1, 195, 196, + 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, + -1, 208, -1, 210, 211, 212, 213, 214, 215, 216, + 217, -1, 219, -1, 221, -1, -1, 224, -1, 226, + 227, 228, 229, 230, 231, -1, -1, 234, -1, 236, + -1, -1, 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, -1, 270, 271, 272, 273, 274, -1, 276, + 277, -1, 279, -1, 281, 282, 283, 284, 285, 286, + -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, + 297, 298, 299, -1, 301, -1, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, + -1, -1, 319, 320, 321, -1, 323, 324, 325, 326, + 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, + 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, + -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, + 357, 358, 359, 360, -1, 362, 363, -1, 365, 366, + 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, 379, 380, 381, -1, -1, 384, 385, 386, + 387, 388, 389, 390, 391, 392, -1, -1, 395, 396, + 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 409, 410, 411, 412, 413, 414, -1, -1, + 417, 418, -1, 420, -1, 422, 423, 424, 425, 426, + -1, 428, 429, 430, -1, -1, 433, 434, 435, 436, + 437, -1, 439, 440, 441, 442, 443, 444, 445, 446, + -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, + -1, 458, 459, 460, 461, 462, 463, 464, 465, -1, + 467, -1, 469, 470, 471, 472, 473, 474, 475, -1, + -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, + 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 497, 498, 499, 500, 501, 3, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, + 28, 29, -1, 31, 32, 33, -1, -1, -1, -1, + -1, -1, 40, -1, -1, 43, 44, -1, 46, 47, + 48, -1, 50, 51, 52, 53, 54, -1, 56, 57, + -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, + 68, 69, 70, 71, 72, 73, -1, 75, 76, 77, + 78, 79, -1, -1, -1, 83, 84, 85, 86, 87, + 88, -1, 90, 91, 92, -1, 94, 95, 96, 97, + 98, 99, -1, -1, 102, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, + 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, + 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, + 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, -1, 161, -1, 163, 164, 165, 166, -1, + 168, -1, 170, -1, -1, -1, 174, 175, 176, -1, + 178, -1, 180, -1, 182, 183, 184, 185, -1, 187, + 188, 189, 190, 191, 192, 193, -1, 195, 196, 197, + 198, -1, 200, 201, 202, 203, 204, 205, 206, -1, + 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, + -1, 219, -1, 221, -1, -1, 224, -1, 226, 227, + 228, 229, 230, 231, -1, -1, 234, -1, 236, -1, + -1, 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, -1, 270, 271, 272, 273, 274, -1, 276, 277, + -1, 279, -1, 281, 282, 283, 284, 285, 286, -1, + 288, 289, -1, -1, 292, 293, 294, -1, -1, 297, + 298, 299, -1, 301, -1, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, -1, -1, -1, + -1, 319, 320, 321, -1, 323, 324, 325, 326, 327, + 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, + 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, -1, 362, 363, -1, 365, 366, 367, + 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, + 378, 379, 380, 381, -1, -1, 384, 385, 386, 387, + 388, -1, 390, 391, 392, -1, -1, 395, 396, 397, + 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, + 408, 409, 410, 411, 412, 413, 414, -1, -1, 417, + 418, -1, 420, -1, 422, 423, 424, 425, 426, -1, + 428, 429, 430, -1, -1, 433, 434, 435, 436, 437, + -1, 439, 440, 441, 442, 443, 444, 445, 446, -1, + -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, + 458, 459, 460, 461, 462, 463, 464, 465, -1, 467, + -1, 469, 470, 471, 472, 473, 474, 475, -1, -1, + 478, -1, -1, 481, 482, 483, 484, 485, 486, 487, + 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, + 498, 499, 500, 501, 3, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, + 29, -1, 31, 32, 33, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 43, 44, -1, 46, 47, 48, + -1, 50, 51, 52, 53, 54, -1, 56, 57, -1, + 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, + 69, 70, 71, 72, 73, -1, 75, 76, 77, 78, + 79, -1, -1, -1, 83, 84, 85, 86, 87, 88, + -1, 90, 91, 92, -1, 94, 95, 96, 97, 98, + 99, -1, -1, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, + -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, + 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, + -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, + 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, -1, 161, -1, 163, 164, 165, 166, -1, 168, + -1, 170, -1, -1, -1, 174, 175, 176, -1, 178, + -1, 180, -1, 182, 183, 184, 185, -1, 187, 188, + 189, 190, 191, 192, 193, -1, 195, 196, 197, 198, + -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, + -1, 210, 211, 212, 213, 214, 215, 216, 217, -1, + 219, -1, 221, -1, -1, 224, -1, 226, 227, 228, + 229, 230, 231, -1, -1, 234, -1, 236, -1, -1, + 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, + -1, 270, 271, 272, 273, 274, -1, 276, 277, -1, + 279, -1, 281, 282, 283, 284, 285, 286, -1, 288, + 289, -1, -1, 292, 293, 294, -1, -1, 297, 298, + 299, -1, 301, -1, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, -1, -1, -1, -1, + 319, 320, 321, -1, 323, 324, 325, 326, 327, 328, + -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, + 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, + 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, + 359, 360, -1, 362, 363, -1, 365, 366, 367, 368, + 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, + 379, 380, 381, -1, -1, 384, 385, 386, 387, 388, + 389, 390, 391, 392, -1, -1, 395, 396, 397, 398, + -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, + 409, 410, 411, 412, 413, 414, -1, -1, 417, 418, + -1, 420, -1, 422, 423, 424, 425, 426, -1, 428, + 429, 430, -1, -1, 433, 434, 435, 436, 437, -1, + 439, 440, 441, 442, 443, 444, 445, 446, -1, -1, + 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, + 459, 460, 461, 462, 463, 464, 465, -1, 467, -1, + 469, 470, 471, 472, 473, 474, 475, -1, -1, 478, + -1, -1, 481, 482, 483, 484, 485, 486, 487, 488, + 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, + 499, 500, 501, 3, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, + -1, 31, 32, 33, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, + 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, + 60, 61, 62, 63, 64, -1, -1, 67, 68, 69, + 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, + -1, -1, -1, 83, 84, 85, 86, 87, 88, -1, + 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, + -1, -1, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, + 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, + 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, + 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + -1, 161, -1, 163, 164, 165, 166, -1, 168, -1, + 170, -1, -1, -1, 174, 175, 176, -1, 178, -1, + 180, -1, 182, 183, 184, 185, -1, 187, 188, 189, + 190, 191, 192, 193, -1, 195, 196, 197, 198, -1, + 200, 201, 202, 203, 204, 205, 206, -1, 208, -1, + 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, + -1, 221, -1, -1, 224, -1, 226, 227, 228, 229, + 230, 231, -1, -1, 234, -1, 236, -1, -1, 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, -1, + 270, 271, 272, 273, 274, -1, 276, 277, -1, 279, + -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, + -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, + -1, 301, -1, 303, 304, 305, 306, 307, 308, 309, + 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, + 320, 321, -1, 323, 324, 325, 326, 327, 328, -1, + 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, + 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, -1, 362, 363, -1, 365, 366, 367, 368, 369, + 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, + 380, 381, -1, -1, 384, 385, 386, 387, 388, 389, + 390, 391, 392, -1, -1, 395, 396, 397, 398, -1, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, -1, -1, 417, 418, -1, + 420, -1, 422, 423, 424, 425, 426, -1, 428, 429, + 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, + 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, + 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, + 460, 461, 462, 463, 464, 465, -1, 467, -1, 469, + 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, + -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, + 500, 501, 3, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, + 31, 32, 33, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 43, 44, -1, 46, 47, 48, -1, 50, + 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, + 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, + 71, 72, 73, -1, 75, 76, 77, 78, 79, -1, + -1, -1, 83, 84, 85, 86, 87, 88, -1, 90, + 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, + -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, + 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, + 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, + 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, -1, + 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, + -1, -1, -1, 174, 175, 176, -1, 178, -1, 180, + -1, 182, 183, 184, 185, -1, 187, 188, 189, 190, + 191, 192, 193, -1, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, -1, 210, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, -1, -1, 224, -1, 226, 227, 228, 229, 230, + 231, -1, -1, 234, -1, 236, -1, -1, 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, -1, 270, + 271, 272, 273, 274, -1, 276, 277, -1, 279, -1, + 281, 282, 283, 284, 285, 286, -1, 288, 289, -1, + -1, 292, 293, 294, -1, -1, 297, 298, 299, -1, + 301, -1, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, + 321, -1, 323, 324, 325, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, -1, 365, 366, 367, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, -1, -1, 384, 385, 386, 387, 388, 389, 390, + 391, 392, -1, -1, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, 417, 418, -1, 420, + -1, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, 435, 436, 437, -1, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, 463, 464, 465, -1, 467, -1, 469, 470, + 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, + 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + 501, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, + 32, 33, -1, -1, -1, 37, -1, -1, -1, -1, + 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, + 52, -1, 54, 55, 56, 57, -1, 59, 60, 61, + 62, 63, 64, -1, -1, 67, 68, 69, 70, 71, + 72, 73, -1, 75, 76, 77, 78, -1, -1, 81, + -1, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, -1, 94, 95, 96, 97, 98, 99, -1, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, + 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, + -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, + 142, -1, 144, 145, 146, -1, 148, 149, 150, 151, + -1, 153, 154, 155, 156, 157, 158, -1, -1, 161, + -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, + -1, 173, 174, 175, -1, 177, 178, -1, 180, -1, + -1, -1, 184, 185, -1, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, + 202, 203, 204, 205, 206, -1, 208, 209, -1, 211, + 212, 213, 214, 215, 216, 217, -1, 219, -1, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + -1, -1, 234, 235, 236, 237, -1, 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, -1, 276, 277, 278, 279, -1, -1, + 282, 283, 284, 285, 286, -1, 288, 289, -1, -1, + 292, 293, 294, -1, -1, 297, 298, -1, 300, 301, + 302, -1, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, -1, -1, -1, -1, 319, 320, -1, + 322, 323, 324, -1, 326, 327, 328, -1, 330, 331, + 332, 333, 334, 335, -1, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, + 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, + 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, + -1, 383, 384, 385, 386, 387, 388, 389, 390, 391, + 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, + 412, 413, -1, -1, -1, 417, 418, -1, 420, 421, + 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, + -1, 433, 434, -1, 436, -1, -1, 439, 440, 441, + 442, 443, 444, 445, 446, 447, -1, 449, 450, 451, + -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, + 462, -1, 464, 465, -1, 467, 468, 469, 470, 471, + 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, + 482, 483, 484, 485, 486, 3, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 498, 499, 500, 501, -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, 37, -1, -1, -1, -1, 42, 43, 44, -1, 46, 47, @@ -19117,7 +19150,7 @@ static const yytype_int16 yycheck[] = 144, 145, 146, -1, 148, 149, 150, 151, -1, 153, 154, 155, 156, 157, 158, -1, -1, 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, 171, -1, 173, - 174, 175, -1, 177, 178, -1, 180, -1, -1, -1, + 174, 175, 176, 177, 178, -1, 180, -1, -1, -1, 184, 185, -1, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, -1, 208, 209, -1, 211, 212, 213, @@ -19136,216 +19169,168 @@ static const yytype_int16 yycheck[] = 334, 335, -1, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, -1, 362, 363, - 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, + 364, 365, 366, 367, -1, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, -1, 383, - 384, 385, 386, 387, 388, 389, 390, 391, 392, -1, + 384, 385, 386, 387, 388, 389, -1, 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, -1, -1, -1, 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, -1, -1, 433, 434, -1, 436, -1, -1, 439, 440, 441, 442, 443, - 444, 445, 446, 447, -1, 449, 450, 451, -1, 453, + 444, 445, 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, 461, 462, -1, 464, 465, -1, 467, 468, 469, 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, 486, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 498, 499, 500, 501, -1, -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, - -1, 31, 32, 33, -1, -1, -1, 37, -1, -1, - -1, -1, 42, 43, 44, -1, 46, 47, 48, 49, - 50, 51, 52, -1, 54, 55, 56, 57, -1, 59, + -1, 31, 32, 33, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 43, 44, -1, 46, 47, 48, -1, + 50, 51, 52, 53, 54, -1, 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, 67, 68, 69, - 70, 71, 72, 73, -1, 75, 76, 77, 78, -1, - -1, 81, -1, 83, 84, 85, 86, 87, 88, 89, + 70, 71, 72, 73, -1, 75, 76, 77, 78, 79, + -1, -1, -1, 83, 84, 85, 86, 87, 88, -1, 90, 91, 92, -1, 94, 95, 96, 97, 98, 99, - -1, 101, 102, 103, 104, 105, 106, 107, 108, 109, + -1, -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, -1, 148, 149, - 150, 151, -1, 153, 154, 155, 156, 157, 158, -1, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, -1, 161, -1, 163, 164, 165, 166, -1, 168, -1, - 170, 171, -1, 173, 174, 175, 176, 177, 178, -1, - 180, -1, -1, -1, 184, 185, -1, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, -1, - 200, 201, 202, 203, 204, 205, 206, -1, 208, 209, - -1, 211, 212, 213, 214, 215, 216, 217, -1, 219, - -1, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, -1, -1, 234, 235, 236, 237, -1, 239, + 170, -1, -1, -1, 174, 175, 176, -1, 178, -1, + 180, -1, 182, 183, -1, 185, -1, 187, 188, 189, + 190, 191, 192, 193, -1, 195, 196, 197, 198, -1, + 200, 201, 202, 203, 204, 205, 206, -1, 208, -1, + 210, 211, 212, 213, 214, 215, 216, 217, -1, 219, + -1, 221, -1, -1, 224, -1, 226, 227, 228, 229, + 230, 231, -1, -1, 234, -1, 236, -1, -1, 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, -1, 276, 277, 278, 279, - -1, -1, 282, 283, 284, 285, 286, -1, 288, 289, - -1, -1, 292, 293, 294, -1, -1, 297, 298, -1, - 300, 301, 302, -1, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, -1, -1, -1, -1, 319, - 320, -1, 322, 323, 324, -1, 326, 327, 328, -1, + 260, 261, 262, 263, 264, 265, 266, 267, 268, -1, + 270, 271, 272, 273, 274, -1, 276, 277, -1, 279, + -1, 281, 282, 283, 284, 285, 286, -1, 288, 289, + -1, -1, 292, 293, 294, -1, -1, 297, 298, 299, + -1, 301, -1, 303, 304, 305, 306, 307, 308, 309, + -1, 311, 312, 313, 314, -1, -1, -1, -1, 319, + 320, 321, -1, 323, 324, 325, 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, 337, 338, 339, - 340, 341, 342, 343, 344, 345, 346, -1, 348, 349, - 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, - 360, -1, 362, 363, 364, 365, 366, 367, -1, 369, - 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, - 380, 381, -1, 383, 384, 385, 386, 387, 388, 389, - -1, 391, 392, -1, 394, 395, 396, 397, 398, -1, - 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, - 410, 411, 412, 413, -1, -1, -1, 417, 418, -1, - 420, 421, 422, 423, 424, 425, 426, -1, 428, 429, - 430, -1, -1, 433, 434, -1, 436, -1, -1, 439, - 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, - 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, - 460, 461, 462, -1, 464, 465, -1, 467, 468, 469, - 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, - -1, 481, 482, 483, 484, 485, 486, 3, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 498, 499, - 500, 501, -1, -1, -1, -1, 22, 23, 24, 25, - 26, 27, 28, 29, -1, 31, 32, 33, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 43, 44, -1, - 46, 47, 48, -1, 50, 51, 52, 53, 54, -1, - 56, 57, -1, 59, 60, 61, 62, 63, 64, -1, - -1, 67, 68, 69, 70, 71, 72, 73, -1, 75, - 76, 77, 78, 79, -1, -1, -1, 83, 84, 85, - 86, 87, 88, -1, 90, 91, 92, -1, 94, 95, - 96, 97, 98, 99, -1, -1, 102, 103, 104, 105, - 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, - 116, -1, 118, -1, 120, 121, 122, 123, 124, 125, - -1, -1, 128, 129, 130, 131, -1, -1, 134, 135, - 136, 137, 138, -1, 140, 141, 142, -1, 144, 145, - 146, -1, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, -1, 161, -1, 163, 164, 165, - 166, -1, 168, -1, 170, -1, -1, -1, 174, 175, - 176, -1, 178, -1, 180, -1, 182, 183, -1, 185, - -1, 187, 188, 189, 190, 191, 192, 193, -1, 195, - 196, 197, 198, -1, 200, 201, 202, 203, 204, 205, - 206, -1, 208, -1, 210, 211, 212, 213, 214, 215, - 216, 217, -1, 219, -1, 221, -1, -1, 224, -1, - 226, 227, 228, 229, 230, 231, -1, -1, 234, -1, - 236, -1, -1, 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, -1, 270, 271, 272, 273, 274, -1, - 276, 277, -1, 279, -1, 281, 282, 283, 284, 285, - 286, -1, 288, 289, -1, -1, 292, 293, 294, -1, - -1, 297, 298, 299, -1, 301, -1, 303, 304, 305, - 306, 307, 308, 309, -1, 311, 312, 313, 314, -1, - -1, -1, -1, 319, 320, 321, -1, 323, 324, 325, - 326, 327, 328, -1, 330, 331, 332, 333, 334, 335, - -1, 337, 338, 339, -1, 341, 342, 343, 344, 345, - 346, -1, 348, 349, 350, 351, 352, 353, 354, 355, - 356, 357, 358, 359, 360, -1, 362, 363, -1, 365, - 366, 367, 368, -1, 370, 371, 372, 373, 374, 375, - 376, 377, 378, 379, 380, 381, -1, -1, 384, 385, - 386, 387, 388, 389, 390, 391, 392, -1, -1, 395, - 396, 397, 398, -1, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, 410, 411, 412, 413, 414, -1, - -1, 417, 418, -1, 420, -1, 422, 423, 424, 425, - 426, -1, 428, 429, 430, -1, -1, 433, 434, 435, - 436, 437, -1, 439, 440, 441, 442, 443, 444, 445, - 446, -1, -1, 449, 450, 451, -1, 453, 454, 455, - 456, -1, 458, 459, 460, 461, 462, 463, 464, 465, - -1, 467, -1, 469, 470, 471, 472, 473, 474, 475, - -1, -1, 478, -1, -1, 481, 482, 483, 484, 485, - 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, - 496, 497, 498, 499, 500, 501, 3, -1, -1, -1, + -1, 341, 342, 343, 344, 345, 346, -1, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, -1, 362, 363, -1, 365, 366, 367, 368, -1, + 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, + 380, 381, -1, -1, 384, 385, 386, 387, 388, 389, + 390, 391, 392, -1, -1, 395, 396, 397, 398, -1, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, -1, -1, 417, 418, -1, + 420, -1, 422, 423, 424, 425, 426, -1, 428, 429, + 430, -1, -1, 433, 434, 435, 436, 437, -1, 439, + 440, 441, 442, 443, 444, 445, 446, -1, -1, 449, + 450, 451, -1, 453, 454, 455, 456, -1, 458, 459, + 460, 461, 462, 463, 464, 465, -1, 467, -1, 469, + 470, 471, 472, 473, 474, 475, -1, -1, 478, -1, + -1, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, + 500, 501, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 22, 23, 24, 25, 26, - 27, 28, 29, -1, 31, 32, 33, -1, -1, -1, - 37, -1, -1, -1, -1, 42, 43, 44, -1, 46, - 47, 48, 49, 50, 51, 52, -1, 54, 55, 56, - 57, -1, 59, 60, 61, 62, 63, 64, -1, -1, - 67, 68, 69, 70, 71, 72, 73, -1, 75, 76, - 77, 78, -1, -1, 81, -1, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, -1, 94, 95, 96, - 97, 98, 99, -1, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - -1, 118, -1, 120, 121, 122, 123, 124, 125, -1, - -1, 128, 129, 130, 131, -1, -1, 134, 135, 136, - 137, 138, -1, 140, 141, 142, -1, 144, 145, 146, - -1, 148, 149, 150, 151, -1, 153, 154, 155, 156, - 157, 158, -1, -1, 161, -1, 163, 164, 165, 166, - -1, 168, -1, 170, 171, -1, 173, 174, 175, -1, - 177, 178, -1, 180, -1, -1, -1, 184, 185, -1, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, -1, 200, 201, 202, 203, 204, 205, 206, - -1, 208, 209, -1, 211, 212, 213, 214, 215, 216, - 217, -1, 219, -1, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, -1, -1, 234, 235, 236, - 237, -1, 239, 240, 241, 242, 243, 244, 245, 246, - -1, 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, -1, 276, - 277, 278, 279, -1, -1, 282, 283, 284, 285, 286, - -1, 288, 289, -1, -1, 292, 293, 294, -1, -1, - 297, 298, -1, 300, 301, 302, -1, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, -1, -1, - -1, -1, 319, 320, -1, 322, 323, 324, -1, 326, - 327, 328, -1, 330, 331, 332, 333, 334, 335, -1, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - -1, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, -1, 362, 363, 364, 365, 366, - 367, -1, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, -1, 383, 384, 385, 386, - 387, 388, 389, -1, 391, 392, -1, 394, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, -1, 413, -1, -1, -1, - 417, 418, -1, 420, 421, 422, 423, 424, 425, 426, - -1, 428, 429, 430, -1, -1, 433, 434, -1, 436, - -1, -1, 439, 440, 441, 442, 443, 444, 445, 446, - -1, -1, 449, 450, 451, -1, 453, 454, 455, 456, - -1, 458, 459, 460, 461, 462, -1, 464, 465, -1, - 467, 468, 469, 470, 471, 472, 473, 474, 475, -1, - 22, 478, -1, -1, 481, 482, 483, 484, 485, 486, - 32, -1, 34, 35, -1, -1, -1, -1, 22, -1, - -1, 498, 499, 500, 501, -1, -1, -1, 32, -1, - 52, -1, -1, -1, -1, -1, -1, -1, -1, 61, - -1, -1, -1, -1, -1, -1, -1, -1, 52, -1, - -1, -1, -1, 75, -1, -1, -1, 61, -1, -1, - -1, -1, -1, -1, 86, -1, -1, -1, -1, -1, - -1, 75, -1, -1, -1, -1, 98, -1, 100, -1, - -1, -1, 86, -1, -1, -1, -1, -1, -1, 111, - -1, -1, -1, -1, 98, -1, 100, -1, -1, -1, - -1, -1, -1, -1, 126, 127, -1, 111, -1, -1, - -1, -1, -1, -1, -1, 137, -1, -1, -1, -1, - -1, 143, 126, 127, -1, -1, -1, -1, -1, 151, - -1, -1, -1, 137, -1, -1, -1, -1, -1, 143, - -1, -1, -1, -1, -1, -1, 168, 151, -1, -1, - 172, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 168, -1, -1, -1, 172, -1, + -1, 22, 23, 24, 25, 26, 27, 28, 29, -1, + 31, 32, 33, -1, -1, -1, 37, -1, -1, -1, + -1, 42, 43, 44, -1, 46, 47, 48, 49, 50, + 51, 52, -1, 54, 55, 56, 57, -1, 59, 60, + 61, 62, 63, 64, -1, -1, 67, 68, 69, 70, + 71, 72, 73, -1, 75, 76, 77, 78, -1, -1, + 81, -1, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, -1, 94, 95, 96, 97, 98, 99, -1, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, -1, 118, -1, 120, + 121, 122, 123, 124, 125, -1, -1, 128, 129, 130, + 131, -1, -1, 134, 135, 136, 137, 138, -1, 140, + 141, 142, -1, 144, 145, 146, -1, 148, 149, 150, + 151, -1, 153, 154, 155, 156, 157, 158, -1, -1, + 161, -1, 163, 164, 165, 166, -1, 168, -1, 170, + 171, -1, 173, 174, 175, -1, 177, 178, -1, 180, + -1, -1, -1, 184, 185, -1, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, -1, 200, + 201, 202, 203, 204, 205, 206, -1, 208, 209, -1, + 211, 212, 213, 214, 215, 216, 217, -1, 219, -1, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, -1, -1, 234, 235, 236, 237, -1, 239, 240, + 241, 242, 243, 244, 245, 246, -1, 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, -1, 276, 277, 278, 279, -1, + -1, 282, 283, 284, 285, 286, -1, 288, 289, -1, + -1, 292, 293, 294, -1, -1, 297, 298, -1, 300, + 301, 302, -1, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, -1, -1, -1, -1, 319, 320, + -1, 322, 323, 324, -1, 326, 327, 328, -1, 330, + 331, 332, 333, 334, 335, -1, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, -1, 348, 349, 350, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, + -1, 362, 363, 364, 365, 366, 367, -1, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, -1, 383, 384, 385, 386, 387, 388, 389, -1, + 391, 392, -1, 394, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, + 411, -1, 413, -1, -1, -1, 417, 418, -1, 420, + 421, 422, 423, 424, 425, 426, -1, 428, 429, 430, + -1, -1, 433, 434, -1, 436, -1, -1, 439, 440, + 441, 442, 443, 444, 445, 446, -1, -1, 449, 450, + 451, -1, 453, 454, 455, 456, -1, 458, 459, 460, + 461, 462, -1, 464, 465, -1, 467, 468, 469, 470, + 471, 472, 473, 474, 475, -1, 22, 478, -1, -1, + 481, 482, 483, 484, 485, 486, 32, -1, 34, 35, + -1, -1, -1, -1, 22, -1, -1, 498, 499, 500, + 501, -1, -1, -1, 32, -1, 52, -1, -1, -1, + -1, -1, -1, -1, -1, 61, -1, -1, -1, -1, + -1, -1, -1, -1, 52, -1, -1, -1, -1, 75, + -1, -1, -1, 61, -1, -1, -1, -1, -1, -1, + 86, -1, -1, -1, -1, -1, -1, 75, -1, -1, + -1, -1, 98, -1, 100, -1, -1, -1, 86, -1, + -1, -1, -1, -1, -1, 111, -1, -1, -1, -1, + 98, -1, 100, -1, -1, -1, -1, -1, -1, -1, + 126, 127, -1, 111, -1, -1, -1, -1, -1, -1, + -1, 137, -1, -1, -1, -1, -1, 143, 126, 127, + -1, -1, -1, -1, -1, 151, -1, -1, -1, 137, + -1, -1, -1, -1, -1, 143, -1, -1, -1, -1, + -1, -1, 168, 151, -1, -1, 172, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 168, -1, -1, -1, 172, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 214, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 214, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 214, -1, -1, -1, -1, -1, -1, -1, 240, -1, + -1, -1, -1, -1, -1, -1, 214, -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, 240, -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, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 315, + 316, 317, -1, -1, -1, -1, -1, 323, -1, -1, + 326, -1, -1, -1, -1, -1, -1, 315, 316, 317, + -1, -1, -1, -1, -1, 323, -1, -1, 326, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 315, 316, 317, -1, -1, -1, -1, - -1, 323, -1, -1, 326, -1, -1, -1, -1, -1, - -1, 315, 316, 317, -1, -1, -1, -1, -1, 323, - -1, -1, 326, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 357, -1, -1, -1, -1, - -1, -1, -1, -1, 366, -1, -1, -1, -1, -1, - -1, -1, -1, 357, -1, -1, -1, -1, -1, -1, - 382, -1, 366, -1, -1, -1, -1, 389, -1, -1, - -1, 393, -1, -1, -1, -1, -1, -1, 382, -1, - -1, 403, -1, -1, -1, 389, -1, -1, -1, 393, - -1, -1, -1, 415, -1, -1, -1, 419, -1, 403, + -1, 357, -1, -1, -1, -1, -1, -1, -1, -1, + 366, -1, -1, -1, -1, -1, -1, -1, -1, 357, + -1, -1, -1, -1, -1, -1, 382, -1, 366, -1, + -1, -1, -1, 389, -1, -1, -1, 393, -1, -1, + -1, -1, -1, -1, 382, -1, -1, 403, -1, -1, + -1, 389, -1, -1, -1, 393, -1, -1, -1, 415, + -1, -1, -1, 419, -1, 403, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 415, -1, -1, + -1, 419, -1, 439, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 452, -1, -1, -1, + -1, 439, 458, -1, -1, -1, -1, 463, -1, -1, + -1, -1, 468, -1, 452, -1, -1, -1, -1, -1, + 458, -1, -1, -1, 480, 463, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 415, -1, -1, -1, 419, -1, 439, -1, -1, + -1, -1, 480, -1, -1, -1, -1, -1, 504, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 452, -1, -1, -1, -1, 439, 458, -1, -1, -1, - -1, 463, -1, -1, -1, -1, 468, -1, 452, -1, - -1, -1, -1, -1, 458, -1, -1, -1, 480, 463, + -1, -1, 518, -1, -1, -1, 504, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 480, -1, -1, -1, - -1, -1, 504, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 518, -1, -1, -1, - 504, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 518 + 518 }; /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing @@ -19535,185 +19520,185 @@ static const yytype_uint16 yystos[] = 59, 596, 594, 594, 106, 251, 261, 59, 431, 480, 504, 593, 266, 373, 593, 595, 775, 93, 431, 554, 373, 545, 431, 373, 989, 546, 676, 517, 523, 875, - 875, 876, 519, 522, 710, 711, 13, 14, 222, 222, - 431, 431, 546, 638, 643, 480, 679, 545, 380, 345, - 384, 419, 470, 665, 152, 100, 580, 604, 940, 941, - 1000, 144, 788, 275, 199, 585, 545, 275, 581, 592, - 275, 518, 639, 40, 275, 639, 275, 518, 659, 660, - 661, 662, 663, 664, 666, 192, 546, 633, 945, 552, - 152, 172, 599, 655, 551, 520, 930, 920, 923, 923, - 930, 519, 522, 13, 959, 965, 4, 926, 4, 926, - 548, 552, 678, 685, 55, 102, 123, 141, 145, 168, - 171, 187, 280, 288, 310, 339, 682, 40, 519, 824, - 519, 172, 522, 519, 318, 881, 519, 825, 825, 11, - 15, 16, 19, 20, 21, 199, 222, 292, 505, 506, - 507, 509, 510, 511, 512, 513, 514, 866, 825, 519, - 777, 778, 836, 167, 172, 884, 885, 522, 519, 40, - 886, 873, 886, 886, 172, 519, 40, 769, 518, 921, - 4, 9, 546, 720, 721, 723, 724, 829, 904, 902, - 178, 241, 419, 423, 425, 451, 545, 703, 477, 781, - 519, 758, 758, 225, 758, 290, 457, 774, 758, 225, - 904, 758, 758, 282, 282, 518, 758, 547, 782, 783, - 518, 547, 782, 522, 519, 522, 520, 518, 791, 518, - 518, 520, 39, 790, 518, 810, 811, 812, 813, 814, - 815, 816, 817, 818, 819, 820, 821, 822, 823, 519, - 522, 794, 555, 560, 667, 668, 686, 937, 982, 994, - 873, 874, 518, 476, 889, 890, 824, 874, 926, 824, - 859, 860, 861, 862, 806, 806, 8, 15, 16, 19, - 20, 21, 505, 506, 507, 509, 510, 511, 512, 513, - 514, 546, 864, 869, 519, 873, 429, 429, 926, 926, - 518, 518, 547, 907, 355, 914, 167, 517, 519, 522, - 523, 522, 528, 511, 824, 550, 873, 926, 824, 823, - 823, 788, 824, 824, 824, 824, 824, 824, 824, 824, - 5, 552, 934, 429, 45, 416, 901, 930, 824, 824, - 518, 687, 830, 887, 895, 132, 160, 275, 280, 285, - 438, 449, 824, 280, 518, 824, 431, 53, 177, 194, - 199, 237, 394, 824, 824, 824, 824, 824, 824, 824, - 824, 824, 824, 30, 38, 399, 863, 516, 520, 899, - 181, 163, 841, 368, 518, 855, 905, 172, 754, 875, - 754, 518, 548, 546, 545, 978, 545, 986, 824, 522, - 519, 250, 275, 701, 457, 985, 545, 557, 518, 546, - 562, 572, 573, 575, 41, 126, 714, 522, 457, 714, - 266, 689, 368, 369, 509, 510, 730, 732, 826, 392, - 227, 291, 313, 313, 522, 513, 4, 731, 926, 731, - 368, 369, 732, 545, 919, 279, 396, 751, 518, 921, - 922, 522, 181, 457, 199, 181, 220, 746, 717, 519, - 546, 548, 546, 548, 353, 541, 518, 192, 631, 923, - 227, 275, 227, 457, 518, 624, 787, 788, 923, 546, - 192, 923, 192, 546, 26, 137, 389, 537, 540, 552, - 615, 629, 923, 552, 623, 642, 923, 538, 923, 353, - 389, 541, 592, 594, 930, 923, 594, 930, 923, 594, - 353, 389, 541, 923, 923, 923, 923, 353, 389, 541, - 923, 923, 548, 510, 824, 896, 710, 710, 710, 466, - 876, 193, 358, 709, 824, 824, 280, 548, 952, 280, - 952, 546, 334, 675, 519, 522, 288, 172, 431, 670, - 939, 583, 470, 545, 545, 1004, 545, 545, 545, 295, - 650, 518, 687, 152, 3, 518, 518, 152, 152, 237, - 546, 621, 631, 634, 637, 647, 649, 480, 482, 626, - 151, 686, 152, 480, 946, 152, 519, 875, 522, 522, - 40, 275, 290, 546, 3, 656, 551, 656, 290, 656, - 588, 824, 676, 247, 511, 516, 518, 594, 677, 831, - 832, 833, 964, 519, 522, 40, 674, 548, 674, 275, - 280, 339, 674, 59, 674, 788, 519, 824, 824, 824, - 884, 788, 825, 825, 825, 825, 825, 825, 132, 275, - 285, 825, 825, 825, 825, 825, 825, 825, 825, 825, - 825, 519, 522, 40, 779, 824, 824, 885, 884, 788, - 519, 519, 519, 873, 788, 921, 519, 313, 369, 513, - 518, 518, 702, 423, 425, 423, 425, 545, 704, 704, - 704, 824, 181, 734, 774, 774, 758, 824, 518, 758, - 167, 774, 518, 547, 765, 774, 788, 519, 522, 782, - 519, 970, 3, 877, 39, 790, 546, 785, 785, 3, - 516, 516, 926, 431, 431, 431, 431, 788, 454, 519, - 517, 873, 824, 139, 890, 891, 519, 519, 519, 523, - 522, 528, 520, 519, 519, 501, 501, 519, 519, 824, - 907, 908, 909, 520, 518, 824, 911, 353, 918, 546, - 838, 893, 894, 824, 824, 856, 910, 519, 519, 519, - 501, 825, 825, 145, 873, 172, 132, 160, 280, 285, - 438, 449, 518, 145, 869, 824, 416, 901, 824, 887, - 824, 431, 518, 687, 824, 896, 551, 518, 518, 155, - 842, 755, 756, 781, 710, 781, 926, 823, 932, 932, - 250, 518, 756, 477, 984, 40, 59, 558, 568, 575, - 897, 522, 754, 507, 503, 715, 713, 292, 864, 867, - 715, 4, 926, 732, 291, 454, 729, 522, 244, 921, - 695, 59, 904, 518, 547, 59, 266, 976, 976, 431, - 824, 275, 646, 518, 152, 518, 624, 203, 643, 644, - 605, 40, 176, 614, 640, 605, 26, 137, 357, 359, - 389, 534, 535, 536, 542, 543, 152, 656, 152, 656, - 615, 629, 615, 519, 522, 548, 608, 507, 520, 519, - 522, 431, 373, 93, 431, 554, 373, 431, 431, 431, - 373, 990, 523, 517, 523, 709, 709, 709, 876, 282, - 282, 519, 518, 669, 3, 406, 407, 548, 684, 638, - 675, 585, 545, 581, 518, 40, 639, 662, 664, 939, - 355, 419, 548, 577, 578, 583, 685, 643, 545, 545, - 1004, 545, 519, 522, 288, 619, 288, 290, 618, 923, - 480, 1003, 545, 619, 40, 545, 519, 660, 666, 663, - 666, 419, 824, 152, 545, 599, 930, 672, 683, 964, - 678, 548, 548, 280, 643, 511, 643, 548, 511, 643, - 548, 519, 519, 885, 172, 132, 285, 518, 780, 777, - 518, 519, 519, 519, 546, 721, 781, 704, 704, 704, - 704, 545, 545, 545, 59, 186, 743, 774, 921, 518, - 762, 763, 764, 827, 830, 921, 167, 80, 784, 783, - 519, 519, 516, 788, 519, 522, 519, 926, 517, 926, - 519, 811, 813, 814, 815, 814, 815, 815, 519, 427, - 824, 143, 824, 859, 869, 809, 809, 519, 522, 519, - 547, 824, 911, 912, 913, 40, 518, 907, 915, 199, - 522, 519, 914, 823, 824, 36, 36, 824, 519, 824, - 172, 518, 877, 824, 519, 145, 825, 825, 145, 145, - 824, 824, 517, 523, 518, 898, 711, 477, 824, 301, - 846, 522, 734, 709, 734, 519, 937, 824, 361, 566, - 546, 266, 321, 117, 304, 518, 556, 686, 519, 522, - 562, 984, 824, 164, 231, 518, 715, 291, 545, 519, - 922, 181, 687, 688, 904, 922, 923, 923, 519, 152, - 644, 631, 644, 605, 633, 522, 519, 119, 207, 273, - 275, 630, 518, 33, 59, 651, 640, 74, 80, 93, - 117, 119, 207, 275, 280, 329, 347, 448, 457, 610, - 611, 625, 176, 117, 191, 275, 619, 593, 107, 117, - 176, 275, 405, 408, 595, 619, 389, 536, 442, 923, - 546, 540, 3, 37, 42, 49, 55, 81, 83, 89, - 101, 171, 173, 176, 177, 194, 209, 222, 223, 225, - 235, 237, 247, 269, 274, 278, 292, 300, 302, 322, - 364, 383, 390, 394, 412, 421, 441, 447, 468, 509, - 510, 548, 594, 606, 645, 788, 867, 927, 1005, 1011, - 552, 642, 923, 923, 923, 923, 923, 923, 923, 923, - 923, 923, 676, 896, 896, 519, 519, 519, 710, 107, - 373, 520, 593, 684, 518, 518, 637, 686, 946, 650, - 192, 545, 519, 522, 585, 519, 519, 581, 518, 40, - 628, 626, 634, 86, 590, 107, 273, 639, 686, 662, - 664, 40, 40, 687, 688, 633, 457, 943, 656, 519, - 522, 643, 825, 172, 518, 877, 782, 519, 522, 519, - 734, 545, 545, 545, 545, 30, 103, 182, 367, 518, - 735, 736, 737, 738, 739, 740, 741, 824, 824, 479, - 843, 519, 826, 870, 871, 199, 181, 759, 763, 519, - 765, 766, 767, 930, 790, 926, 790, 546, 790, 517, - 517, 824, 907, 522, 519, 546, 915, 916, 917, 40, - 824, 826, 894, 918, 824, 824, 824, 877, 519, 824, - 36, 36, 824, 824, 145, 519, 510, 896, 519, 875, - 519, 824, 519, 518, 546, 847, 743, 519, 743, 548, - 519, 903, 463, 418, 456, 567, 546, 561, 571, 290, - 564, 507, 575, 566, 869, 59, 519, 519, 462, 463, - 692, 605, 631, 519, 519, 480, 636, 120, 195, 205, - 119, 459, 824, 117, 40, 518, 930, 923, 825, 120, - 195, 119, 280, 227, 545, 636, 88, 651, 192, 280, - 594, 824, 651, 280, 509, 510, 597, 546, 787, 788, - 656, 656, 3, 247, 412, 927, 931, 507, 431, 431, - 517, 517, 709, 519, 519, 546, 676, 457, 671, 673, - 685, 643, 519, 1003, 40, 419, 275, 518, 548, 518, - 946, 637, 151, 686, 149, 201, 618, 122, 137, 328, - 1003, 107, 946, 480, 1001, 419, 290, 546, 942, 518, - 683, 825, 877, 519, 519, 9, 354, 727, 743, 518, - 391, 518, 519, 522, 546, 844, 845, 336, 744, 522, - 519, 518, 547, 59, 519, 199, 519, 766, 517, 788, - 911, 522, 519, 546, 517, 192, 519, 824, 824, 824, - 523, 517, 523, 519, 519, 546, 848, 843, 548, 843, - 522, 462, 897, 519, 522, 91, 566, 824, 519, 922, - 922, 347, 636, 518, 627, 605, 519, 191, 518, 824, - 275, 611, 636, 639, 923, 40, 152, 784, 931, 513, - 606, 923, 923, 519, 593, 124, 519, 519, 626, 686, - 545, 152, 685, 40, 519, 923, 1003, 30, 85, 94, - 118, 191, 204, 405, 408, 622, 622, 369, 369, 40, - 64, 74, 241, 687, 545, 518, 546, 565, 574, 836, - 519, 519, 518, 843, 873, 518, 873, 737, 40, 522, - 824, 457, 722, 826, 904, 921, 770, 518, 770, 915, - 824, 896, 896, 310, 849, 744, 744, 686, 304, 686, - 561, 290, 518, 559, 545, 605, 552, 632, 635, 409, - 472, 612, 613, 518, 607, 824, 519, 249, 648, 191, - 457, 539, 513, 442, 676, 548, 946, 618, 1001, 518, - 545, 519, 686, 626, 590, 686, 74, 293, 74, 943, - 824, 80, 569, 519, 522, 569, 9, 744, 519, 736, - 519, 847, 845, 371, 519, 904, 517, 517, 517, 59, - 710, 722, 722, 567, 93, 574, 133, 639, 507, 519, - 522, 592, 519, 273, 620, 173, 309, 395, 290, 616, - 617, 641, 607, 824, 442, 40, 518, 1001, 618, 1003, - 1001, 293, 293, 518, 519, 930, 570, 930, 946, 565, - 570, 519, 722, 519, 724, 519, 872, 184, 340, 369, - 850, 462, 923, 519, 276, 454, 648, 606, 635, 519, - 613, 205, 122, 454, 290, 641, 290, 616, 686, 574, - 569, 714, 781, 714, 53, 104, 444, 824, 851, 852, - 851, 851, 519, 686, 781, 389, 617, 63, 273, 360, - 389, 609, 609, 1001, 519, 570, 715, 715, 852, 368, - 166, 324, 166, 324, 148, 853, 853, 853, 573, 605, - 25, 117, 280, 946, 714, 36, 104, 181, 273, 428, - 781, 781, 715, 852, 368, 298 + 875, 876, 193, 358, 709, 522, 710, 711, 13, 14, + 222, 222, 431, 431, 546, 638, 643, 480, 679, 545, + 380, 345, 384, 419, 470, 665, 152, 100, 580, 604, + 940, 941, 1000, 144, 788, 275, 199, 585, 545, 275, + 581, 592, 275, 518, 639, 40, 275, 639, 275, 518, + 659, 660, 661, 662, 663, 664, 666, 192, 546, 633, + 945, 552, 152, 172, 599, 655, 551, 520, 930, 920, + 923, 923, 930, 519, 522, 13, 959, 965, 4, 926, + 4, 926, 548, 552, 678, 685, 55, 102, 123, 141, + 145, 168, 171, 187, 280, 288, 310, 339, 682, 40, + 519, 824, 519, 172, 522, 519, 318, 881, 519, 825, + 825, 11, 15, 16, 19, 20, 21, 199, 222, 292, + 505, 506, 507, 509, 510, 511, 512, 513, 514, 866, + 825, 519, 777, 778, 836, 167, 172, 884, 885, 522, + 519, 40, 886, 873, 886, 886, 172, 519, 40, 769, + 518, 921, 4, 9, 546, 720, 721, 723, 724, 829, + 904, 902, 178, 241, 419, 423, 425, 451, 545, 703, + 477, 781, 519, 758, 758, 225, 758, 290, 457, 774, + 758, 225, 904, 758, 758, 282, 282, 518, 758, 547, + 782, 783, 518, 547, 782, 522, 519, 522, 520, 518, + 791, 518, 518, 520, 39, 790, 518, 810, 811, 812, + 813, 814, 815, 816, 817, 818, 819, 820, 821, 822, + 823, 519, 522, 794, 555, 560, 667, 668, 686, 937, + 982, 994, 873, 874, 518, 476, 889, 890, 824, 874, + 926, 824, 859, 860, 861, 862, 806, 806, 8, 15, + 16, 19, 20, 21, 505, 506, 507, 509, 510, 511, + 512, 513, 514, 546, 864, 869, 519, 873, 429, 429, + 926, 926, 518, 518, 547, 907, 355, 914, 167, 517, + 519, 522, 523, 522, 528, 511, 824, 550, 873, 926, + 824, 823, 823, 788, 824, 824, 824, 824, 824, 824, + 824, 824, 5, 552, 934, 429, 45, 416, 901, 930, + 824, 824, 518, 687, 830, 887, 895, 132, 160, 275, + 280, 285, 438, 449, 824, 280, 518, 824, 431, 53, + 177, 194, 199, 237, 394, 824, 824, 824, 824, 824, + 824, 824, 824, 824, 824, 30, 38, 399, 863, 516, + 520, 899, 181, 163, 841, 368, 518, 855, 905, 172, + 754, 875, 754, 518, 548, 546, 545, 978, 545, 986, + 824, 522, 519, 250, 275, 701, 457, 985, 545, 557, + 518, 546, 562, 572, 573, 575, 41, 126, 714, 522, + 457, 714, 266, 689, 368, 369, 509, 510, 730, 732, + 826, 392, 227, 291, 313, 313, 522, 513, 4, 731, + 926, 731, 368, 369, 732, 545, 919, 279, 396, 751, + 518, 921, 922, 522, 181, 457, 199, 181, 220, 746, + 717, 519, 546, 548, 546, 548, 353, 541, 518, 192, + 631, 923, 227, 275, 227, 457, 518, 624, 787, 788, + 923, 546, 192, 923, 192, 546, 26, 137, 389, 537, + 540, 552, 615, 629, 923, 552, 623, 642, 923, 538, + 923, 353, 389, 541, 592, 594, 930, 923, 594, 930, + 923, 594, 353, 389, 541, 923, 923, 923, 923, 353, + 389, 541, 923, 923, 548, 510, 824, 896, 710, 710, + 710, 282, 282, 519, 466, 876, 709, 824, 824, 280, + 548, 952, 280, 952, 546, 334, 675, 519, 522, 288, + 172, 431, 670, 939, 583, 470, 545, 545, 1004, 545, + 545, 545, 295, 650, 518, 687, 152, 3, 518, 518, + 152, 152, 237, 546, 621, 631, 634, 637, 647, 649, + 480, 482, 626, 151, 686, 152, 480, 946, 152, 519, + 875, 522, 522, 40, 275, 290, 546, 3, 656, 551, + 656, 290, 656, 588, 824, 676, 247, 511, 516, 518, + 594, 677, 831, 832, 833, 964, 519, 522, 40, 674, + 548, 674, 275, 280, 339, 674, 59, 674, 788, 519, + 824, 824, 824, 884, 788, 825, 825, 825, 825, 825, + 825, 132, 275, 285, 825, 825, 825, 825, 825, 825, + 825, 825, 825, 825, 519, 522, 40, 779, 824, 824, + 885, 884, 788, 519, 519, 519, 873, 788, 921, 519, + 313, 369, 513, 518, 518, 702, 423, 425, 423, 425, + 545, 704, 704, 704, 824, 181, 734, 774, 774, 758, + 824, 518, 758, 167, 774, 518, 547, 765, 774, 788, + 519, 522, 782, 519, 970, 3, 877, 39, 790, 546, + 785, 785, 3, 516, 516, 926, 431, 431, 431, 431, + 788, 454, 519, 517, 873, 824, 139, 890, 891, 519, + 519, 519, 523, 522, 528, 520, 519, 519, 501, 501, + 519, 519, 824, 907, 908, 909, 520, 518, 824, 911, + 353, 918, 546, 838, 893, 894, 824, 824, 856, 910, + 519, 519, 519, 501, 825, 825, 145, 873, 172, 132, + 160, 280, 285, 438, 449, 518, 145, 869, 824, 416, + 901, 824, 887, 824, 431, 518, 687, 824, 896, 551, + 518, 518, 155, 842, 755, 756, 781, 710, 781, 926, + 823, 932, 932, 250, 518, 756, 477, 984, 40, 59, + 558, 568, 575, 897, 522, 754, 507, 503, 715, 713, + 292, 864, 867, 715, 4, 926, 732, 291, 454, 729, + 522, 244, 921, 695, 59, 904, 518, 547, 59, 266, + 976, 976, 431, 824, 275, 646, 518, 152, 518, 624, + 203, 643, 644, 605, 40, 176, 614, 640, 605, 26, + 137, 357, 359, 389, 534, 535, 536, 542, 543, 152, + 656, 152, 656, 615, 629, 615, 519, 522, 548, 608, + 507, 520, 519, 522, 431, 373, 93, 431, 554, 373, + 431, 431, 431, 373, 990, 523, 517, 523, 709, 709, + 709, 876, 519, 518, 669, 3, 406, 407, 548, 684, + 638, 675, 585, 545, 581, 518, 40, 639, 662, 664, + 939, 355, 419, 548, 577, 578, 583, 685, 643, 545, + 545, 1004, 545, 519, 522, 288, 619, 288, 290, 618, + 923, 480, 1003, 545, 619, 40, 545, 519, 660, 666, + 663, 666, 419, 824, 152, 545, 599, 930, 672, 683, + 964, 678, 548, 548, 280, 643, 511, 643, 548, 511, + 643, 548, 519, 519, 885, 172, 132, 285, 518, 780, + 777, 518, 519, 519, 519, 546, 721, 781, 704, 704, + 704, 704, 545, 545, 545, 59, 186, 743, 774, 921, + 518, 762, 763, 764, 827, 830, 921, 167, 80, 784, + 783, 519, 519, 516, 788, 519, 522, 519, 926, 517, + 926, 519, 811, 813, 814, 815, 814, 815, 815, 519, + 427, 824, 143, 824, 859, 869, 809, 809, 519, 522, + 519, 547, 824, 911, 912, 913, 40, 518, 907, 915, + 199, 522, 519, 914, 823, 824, 36, 36, 824, 519, + 824, 172, 518, 877, 824, 519, 145, 825, 825, 145, + 145, 824, 824, 517, 523, 518, 898, 711, 477, 824, + 301, 846, 522, 734, 709, 734, 519, 937, 824, 361, + 566, 546, 266, 321, 117, 304, 518, 556, 686, 519, + 522, 562, 984, 824, 164, 231, 518, 715, 291, 545, + 519, 922, 181, 687, 688, 904, 922, 923, 923, 519, + 152, 644, 631, 644, 605, 633, 522, 519, 119, 207, + 273, 275, 630, 518, 33, 59, 651, 640, 74, 80, + 93, 117, 119, 207, 275, 280, 329, 347, 448, 457, + 610, 611, 625, 176, 117, 191, 275, 619, 593, 107, + 117, 176, 275, 405, 408, 595, 619, 389, 536, 442, + 923, 546, 540, 3, 37, 42, 49, 55, 81, 83, + 89, 101, 171, 173, 176, 177, 194, 209, 222, 223, + 225, 235, 237, 247, 269, 274, 278, 292, 300, 302, + 322, 364, 383, 390, 394, 412, 421, 441, 447, 468, + 509, 510, 548, 594, 606, 645, 788, 867, 927, 1005, + 1011, 552, 642, 923, 923, 923, 923, 923, 923, 923, + 923, 923, 923, 676, 896, 896, 519, 519, 519, 710, + 107, 373, 520, 593, 684, 518, 518, 637, 686, 946, + 650, 192, 545, 519, 522, 585, 519, 519, 581, 518, + 40, 628, 626, 634, 86, 590, 107, 273, 639, 686, + 662, 664, 40, 40, 687, 688, 633, 457, 943, 656, + 519, 522, 643, 825, 172, 518, 877, 782, 519, 522, + 519, 734, 545, 545, 545, 545, 30, 103, 182, 367, + 518, 735, 736, 737, 738, 739, 740, 741, 824, 824, + 479, 843, 519, 826, 870, 871, 199, 181, 759, 763, + 519, 765, 766, 767, 930, 790, 926, 790, 546, 790, + 517, 517, 824, 907, 522, 519, 546, 915, 916, 917, + 40, 824, 826, 894, 918, 824, 824, 824, 877, 519, + 824, 36, 36, 824, 824, 145, 519, 510, 896, 519, + 875, 519, 824, 519, 518, 546, 847, 743, 519, 743, + 548, 519, 903, 463, 418, 456, 567, 546, 561, 571, + 290, 564, 507, 575, 566, 869, 59, 519, 519, 462, + 463, 692, 605, 631, 519, 519, 480, 636, 120, 195, + 205, 119, 459, 824, 117, 40, 518, 930, 923, 825, + 120, 195, 119, 280, 227, 545, 636, 88, 651, 192, + 280, 594, 824, 651, 280, 509, 510, 597, 546, 787, + 788, 656, 656, 3, 247, 412, 927, 931, 507, 431, + 431, 517, 517, 709, 519, 519, 546, 676, 457, 671, + 673, 685, 643, 519, 1003, 40, 419, 275, 518, 548, + 518, 946, 637, 151, 686, 149, 201, 618, 122, 137, + 328, 1003, 107, 946, 480, 1001, 419, 290, 546, 942, + 518, 683, 825, 877, 519, 519, 9, 354, 727, 743, + 518, 391, 518, 519, 522, 546, 844, 845, 336, 744, + 522, 519, 518, 547, 59, 519, 199, 519, 766, 517, + 788, 911, 522, 519, 546, 517, 192, 519, 824, 824, + 824, 523, 517, 523, 519, 519, 546, 848, 843, 548, + 843, 522, 462, 897, 519, 522, 91, 566, 824, 519, + 922, 922, 347, 636, 518, 627, 605, 519, 191, 518, + 824, 275, 611, 636, 639, 923, 40, 152, 784, 931, + 513, 606, 923, 923, 519, 593, 124, 519, 519, 626, + 686, 545, 152, 685, 40, 519, 923, 1003, 30, 85, + 94, 118, 191, 204, 405, 408, 622, 622, 369, 369, + 40, 64, 74, 241, 687, 545, 518, 546, 565, 574, + 836, 519, 519, 518, 843, 873, 518, 873, 737, 40, + 522, 824, 457, 722, 826, 904, 921, 770, 518, 770, + 915, 824, 896, 896, 310, 849, 744, 744, 686, 304, + 686, 561, 290, 518, 559, 545, 605, 552, 632, 635, + 409, 472, 612, 613, 518, 607, 824, 519, 249, 648, + 191, 457, 539, 513, 442, 676, 548, 946, 618, 1001, + 518, 545, 519, 686, 626, 590, 686, 74, 293, 74, + 943, 824, 80, 569, 519, 522, 569, 9, 744, 519, + 736, 519, 847, 845, 371, 519, 904, 517, 517, 517, + 59, 710, 722, 722, 567, 93, 574, 133, 639, 507, + 519, 522, 592, 519, 273, 620, 173, 309, 395, 290, + 616, 617, 641, 607, 824, 442, 40, 518, 1001, 618, + 1003, 1001, 293, 293, 518, 519, 930, 570, 930, 946, + 565, 570, 519, 722, 519, 724, 519, 872, 184, 340, + 369, 850, 462, 923, 519, 276, 454, 648, 606, 635, + 519, 613, 205, 122, 454, 290, 641, 290, 616, 686, + 574, 569, 714, 781, 714, 53, 104, 444, 824, 851, + 852, 851, 851, 519, 686, 781, 389, 617, 63, 273, + 360, 389, 609, 609, 1001, 519, 570, 715, 715, 852, + 368, 166, 324, 166, 324, 148, 853, 853, 853, 573, + 605, 25, 117, 280, 946, 714, 36, 104, 181, 273, + 428, 781, 781, 715, 852, 368, 298 }; #define yyerrok (yyerrstatus = 0) @@ -28081,14 +28066,15 @@ YYLTYPE yylloc; case 1050: #line 2898 "third_party/libpg_query/grammar/statements/select.y" { - PGFuncCall *n = makeFuncCall((yyvsp[(1) - (4)].list), NIL, (yylsp[(1) - (4)])); - n->agg_order = (yyvsp[(3) - (4)].list); + PGFuncCall *n = makeFuncCall((yyvsp[(1) - (5)].list), NIL, (yylsp[(1) - (5)])); + n->agg_order = (yyvsp[(3) - (5)].list); + n->agg_ignore_nulls = (yyvsp[(4) - (5)].ignorenulls); (yyval.node) = (PGNode *)n; ;} break; case 1051: -#line 2904 "third_party/libpg_query/grammar/statements/select.y" +#line 2905 "third_party/libpg_query/grammar/statements/select.y" { PGFuncCall *n = makeFuncCall((yyvsp[(1) - (6)].list), (yyvsp[(3) - (6)].list), (yylsp[(1) - (6)])); n->agg_order = (yyvsp[(4) - (6)].list); @@ -28098,7 +28084,7 @@ YYLTYPE yylloc; break; case 1052: -#line 2911 "third_party/libpg_query/grammar/statements/select.y" +#line 2912 "third_party/libpg_query/grammar/statements/select.y" { PGFuncCall *n = makeFuncCall((yyvsp[(1) - (7)].list), list_make1((yyvsp[(4) - (7)].node)), (yylsp[(1) - (7)])); n->func_variadic = true; @@ -28109,7 +28095,7 @@ YYLTYPE yylloc; break; case 1053: -#line 2919 "third_party/libpg_query/grammar/statements/select.y" +#line 2920 "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)])); n->func_variadic = true; @@ -28120,7 +28106,7 @@ YYLTYPE yylloc; break; case 1054: -#line 2927 "third_party/libpg_query/grammar/statements/select.y" +#line 2928 "third_party/libpg_query/grammar/statements/select.y" { PGFuncCall *n = makeFuncCall((yyvsp[(1) - (7)].list), (yyvsp[(4) - (7)].list), (yylsp[(1) - (7)])); n->agg_order = (yyvsp[(5) - (7)].list); @@ -28134,7 +28120,7 @@ YYLTYPE yylloc; break; case 1055: -#line 2938 "third_party/libpg_query/grammar/statements/select.y" +#line 2939 "third_party/libpg_query/grammar/statements/select.y" { PGFuncCall *n = makeFuncCall((yyvsp[(1) - (7)].list), (yyvsp[(4) - (7)].list), (yylsp[(1) - (7)])); n->agg_order = (yyvsp[(5) - (7)].list); @@ -28145,7 +28131,7 @@ YYLTYPE yylloc; break; case 1056: -#line 2958 "third_party/libpg_query/grammar/statements/select.y" +#line 2959 "third_party/libpg_query/grammar/statements/select.y" { PGFuncCall *n = (PGFuncCall *) (yyvsp[(1) - (5)].node); /* @@ -28184,22 +28170,22 @@ YYLTYPE yylloc; break; case 1057: -#line 2994 "third_party/libpg_query/grammar/statements/select.y" +#line 2995 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; case 1058: -#line 3004 "third_party/libpg_query/grammar/statements/select.y" +#line 3005 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; case 1059: -#line 3005 "third_party/libpg_query/grammar/statements/select.y" +#line 3006 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; case 1060: -#line 3013 "third_party/libpg_query/grammar/statements/select.y" +#line 3014 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("pg_collation_for"), list_make1((yyvsp[(4) - (5)].node)), @@ -28208,24 +28194,24 @@ YYLTYPE yylloc; break; case 1061: -#line 3019 "third_party/libpg_query/grammar/statements/select.y" +#line 3020 "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 1062: -#line 3021 "third_party/libpg_query/grammar/statements/select.y" +#line 3022 "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 1063: -#line 3023 "third_party/libpg_query/grammar/statements/select.y" +#line 3024 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("date_part"), (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)])); ;} break; case 1064: -#line 3027 "third_party/libpg_query/grammar/statements/select.y" +#line 3028 "third_party/libpg_query/grammar/statements/select.y" { /* overlay(A PLACING B FROM C FOR D) is converted to * overlay(A, B, C, D) @@ -28237,7 +28223,7 @@ YYLTYPE yylloc; break; case 1065: -#line 3036 "third_party/libpg_query/grammar/statements/select.y" +#line 3037 "third_party/libpg_query/grammar/statements/select.y" { /* position(A in B) is converted to position_inverse(A, B) */ (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("__internal_position_operator"), (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)])); @@ -28245,7 +28231,7 @@ YYLTYPE yylloc; break; case 1066: -#line 3041 "third_party/libpg_query/grammar/statements/select.y" +#line 3042 "third_party/libpg_query/grammar/statements/select.y" { /* substring(A from B for C) is converted to * substring(A, B, C) - thomas 2000-11-28 @@ -28255,7 +28241,7 @@ YYLTYPE yylloc; break; case 1067: -#line 3048 "third_party/libpg_query/grammar/statements/select.y" +#line 3049 "third_party/libpg_query/grammar/statements/select.y" { /* TREAT(expr AS target) converts expr of a particular type to target, * which is defined to be a subtype of the original expression. @@ -28273,7 +28259,7 @@ YYLTYPE yylloc; break; case 1068: -#line 3063 "third_party/libpg_query/grammar/statements/select.y" +#line 3064 "third_party/libpg_query/grammar/statements/select.y" { /* various trim expressions are defined in SQL * - thomas 1997-07-19 @@ -28283,35 +28269,35 @@ YYLTYPE yylloc; break; case 1069: -#line 3070 "third_party/libpg_query/grammar/statements/select.y" +#line 3071 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("ltrim"), (yyvsp[(4) - (5)].list), (yylsp[(1) - (5)])); ;} break; case 1070: -#line 3074 "third_party/libpg_query/grammar/statements/select.y" +#line 3075 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("rtrim"), (yyvsp[(4) - (5)].list), (yylsp[(1) - (5)])); ;} break; case 1071: -#line 3078 "third_party/libpg_query/grammar/statements/select.y" +#line 3079 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("trim"), (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)])); ;} break; case 1072: -#line 3082 "third_party/libpg_query/grammar/statements/select.y" +#line 3083 "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 1073: -#line 3086 "third_party/libpg_query/grammar/statements/select.y" +#line 3087 "third_party/libpg_query/grammar/statements/select.y" { PGCoalesceExpr *c = makeNode(PGCoalesceExpr); c->args = (yyvsp[(3) - (4)].list); @@ -28321,7 +28307,7 @@ YYLTYPE yylloc; break; case 1074: -#line 3096 "third_party/libpg_query/grammar/statements/select.y" +#line 3097 "third_party/libpg_query/grammar/statements/select.y" { PGFuncCall *n = makeFuncCall(SystemFuncName("row"), (yyvsp[(1) - (1)].list), (yylsp[(1) - (1)])); (yyval.node) = (PGNode *) n; @@ -28329,7 +28315,7 @@ YYLTYPE yylloc; break; case 1075: -#line 3104 "third_party/libpg_query/grammar/statements/select.y" +#line 3105 "third_party/libpg_query/grammar/statements/select.y" { PGLambdaFunction *lambda = makeNode(PGLambdaFunction); lambda->lhs = (yyvsp[(4) - (7)].node); @@ -28341,7 +28327,7 @@ YYLTYPE yylloc; break; case 1076: -#line 3113 "third_party/libpg_query/grammar/statements/select.y" +#line 3114 "third_party/libpg_query/grammar/statements/select.y" { PGLambdaFunction *lambda = makeNode(PGLambdaFunction); lambda->lhs = (yyvsp[(4) - (9)].node); @@ -28359,62 +28345,62 @@ YYLTYPE yylloc; break; case 1077: -#line 3134 "third_party/libpg_query/grammar/statements/select.y" +#line 3135 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(4) - (5)].list); ;} break; case 1078: -#line 3135 "third_party/libpg_query/grammar/statements/select.y" +#line 3136 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; case 1079: -#line 3139 "third_party/libpg_query/grammar/statements/select.y" +#line 3140 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(4) - (5)].node); ;} break; case 1080: -#line 3140 "third_party/libpg_query/grammar/statements/select.y" +#line 3141 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(3) - (4)].node); ;} break; case 1081: -#line 3141 "third_party/libpg_query/grammar/statements/select.y" +#line 3142 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = NULL; ;} break; case 1082: -#line 3145 "third_party/libpg_query/grammar/statements/select.y" +#line 3146 "third_party/libpg_query/grammar/statements/select.y" { (yyval.boolean) = true; ;} break; case 1083: -#line 3146 "third_party/libpg_query/grammar/statements/select.y" +#line 3147 "third_party/libpg_query/grammar/statements/select.y" { (yyval.boolean) = false; ;} break; case 1084: -#line 3153 "third_party/libpg_query/grammar/statements/select.y" +#line 3154 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(2) - (2)].list); ;} break; case 1085: -#line 3154 "third_party/libpg_query/grammar/statements/select.y" +#line 3155 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; case 1086: -#line 3158 "third_party/libpg_query/grammar/statements/select.y" +#line 3159 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].windef)); ;} break; case 1087: -#line 3160 "third_party/libpg_query/grammar/statements/select.y" +#line 3161 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].windef)); ;} break; case 1088: -#line 3165 "third_party/libpg_query/grammar/statements/select.y" +#line 3166 "third_party/libpg_query/grammar/statements/select.y" { PGWindowDef *n = (yyvsp[(3) - (3)].windef); n->name = (yyvsp[(1) - (3)].str); @@ -28423,12 +28409,12 @@ YYLTYPE yylloc; break; case 1089: -#line 3173 "third_party/libpg_query/grammar/statements/select.y" +#line 3174 "third_party/libpg_query/grammar/statements/select.y" { (yyval.windef) = (yyvsp[(2) - (2)].windef); ;} break; case 1090: -#line 3175 "third_party/libpg_query/grammar/statements/select.y" +#line 3176 "third_party/libpg_query/grammar/statements/select.y" { PGWindowDef *n = makeNode(PGWindowDef); n->name = (yyvsp[(2) - (2)].str); @@ -28444,12 +28430,12 @@ YYLTYPE yylloc; break; case 1091: -#line 3188 "third_party/libpg_query/grammar/statements/select.y" +#line 3189 "third_party/libpg_query/grammar/statements/select.y" { (yyval.windef) = NULL; ;} break; case 1092: -#line 3193 "third_party/libpg_query/grammar/statements/select.y" +#line 3194 "third_party/libpg_query/grammar/statements/select.y" { PGWindowDef *n = makeNode(PGWindowDef); n->name = NULL; @@ -28466,27 +28452,27 @@ YYLTYPE yylloc; break; case 1093: -#line 3218 "third_party/libpg_query/grammar/statements/select.y" +#line 3219 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; case 1094: -#line 3219 "third_party/libpg_query/grammar/statements/select.y" +#line 3220 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = NULL; ;} break; case 1095: -#line 3222 "third_party/libpg_query/grammar/statements/select.y" +#line 3223 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(3) - (3)].list); ;} break; case 1096: -#line 3223 "third_party/libpg_query/grammar/statements/select.y" +#line 3224 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; case 1097: -#line 3232 "third_party/libpg_query/grammar/statements/select.y" +#line 3233 "third_party/libpg_query/grammar/statements/select.y" { PGWindowDef *n = (yyvsp[(2) - (3)].windef); @@ -28497,7 +28483,7 @@ YYLTYPE yylloc; break; case 1098: -#line 3240 "third_party/libpg_query/grammar/statements/select.y" +#line 3241 "third_party/libpg_query/grammar/statements/select.y" { PGWindowDef *n = (yyvsp[(2) - (3)].windef); @@ -28508,7 +28494,7 @@ YYLTYPE yylloc; break; case 1099: -#line 3248 "third_party/libpg_query/grammar/statements/select.y" +#line 3249 "third_party/libpg_query/grammar/statements/select.y" { PGWindowDef *n = (yyvsp[(2) - (3)].windef); @@ -28519,7 +28505,7 @@ YYLTYPE yylloc; break; case 1100: -#line 3256 "third_party/libpg_query/grammar/statements/select.y" +#line 3257 "third_party/libpg_query/grammar/statements/select.y" { PGWindowDef *n = makeNode(PGWindowDef); @@ -28531,7 +28517,7 @@ YYLTYPE yylloc; break; case 1101: -#line 3267 "third_party/libpg_query/grammar/statements/select.y" +#line 3268 "third_party/libpg_query/grammar/statements/select.y" { PGWindowDef *n = (yyvsp[(1) - (1)].windef); @@ -28552,7 +28538,7 @@ YYLTYPE yylloc; break; case 1102: -#line 3285 "third_party/libpg_query/grammar/statements/select.y" +#line 3286 "third_party/libpg_query/grammar/statements/select.y" { PGWindowDef *n1 = (yyvsp[(2) - (4)].windef); PGWindowDef *n2 = (yyvsp[(4) - (4)].windef); @@ -28593,7 +28579,7 @@ YYLTYPE yylloc; break; case 1103: -#line 3331 "third_party/libpg_query/grammar/statements/select.y" +#line 3332 "third_party/libpg_query/grammar/statements/select.y" { PGWindowDef *n = makeNode(PGWindowDef); @@ -28605,7 +28591,7 @@ YYLTYPE yylloc; break; case 1104: -#line 3340 "third_party/libpg_query/grammar/statements/select.y" +#line 3341 "third_party/libpg_query/grammar/statements/select.y" { PGWindowDef *n = makeNode(PGWindowDef); @@ -28617,7 +28603,7 @@ YYLTYPE yylloc; break; case 1105: -#line 3349 "third_party/libpg_query/grammar/statements/select.y" +#line 3350 "third_party/libpg_query/grammar/statements/select.y" { PGWindowDef *n = makeNode(PGWindowDef); @@ -28629,7 +28615,7 @@ YYLTYPE yylloc; break; case 1106: -#line 3358 "third_party/libpg_query/grammar/statements/select.y" +#line 3359 "third_party/libpg_query/grammar/statements/select.y" { PGWindowDef *n = makeNode(PGWindowDef); @@ -28641,7 +28627,7 @@ YYLTYPE yylloc; break; case 1107: -#line 3367 "third_party/libpg_query/grammar/statements/select.y" +#line 3368 "third_party/libpg_query/grammar/statements/select.y" { PGWindowDef *n = makeNode(PGWindowDef); @@ -28653,52 +28639,52 @@ YYLTYPE yylloc; break; case 1108: -#line 3378 "third_party/libpg_query/grammar/statements/select.y" +#line 3379 "third_party/libpg_query/grammar/statements/select.y" { (yyval.ival) = FRAMEOPTION_EXCLUDE_CURRENT_ROW; ;} break; case 1109: -#line 3379 "third_party/libpg_query/grammar/statements/select.y" +#line 3380 "third_party/libpg_query/grammar/statements/select.y" { (yyval.ival) = FRAMEOPTION_EXCLUDE_GROUP; ;} break; case 1110: -#line 3380 "third_party/libpg_query/grammar/statements/select.y" +#line 3381 "third_party/libpg_query/grammar/statements/select.y" { (yyval.ival) = FRAMEOPTION_EXCLUDE_TIES; ;} break; case 1111: -#line 3381 "third_party/libpg_query/grammar/statements/select.y" +#line 3382 "third_party/libpg_query/grammar/statements/select.y" { (yyval.ival) = 0; ;} break; case 1112: -#line 3382 "third_party/libpg_query/grammar/statements/select.y" +#line 3383 "third_party/libpg_query/grammar/statements/select.y" { (yyval.ival) = 0; ;} break; case 1113: -#line 3396 "third_party/libpg_query/grammar/statements/select.y" +#line 3397 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; case 1114: -#line 3397 "third_party/libpg_query/grammar/statements/select.y" +#line 3398 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; case 1115: -#line 3400 "third_party/libpg_query/grammar/statements/select.y" +#line 3401 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list);;} break; case 1116: -#line 3401 "third_party/libpg_query/grammar/statements/select.y" +#line 3402 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(2) - (5)].list), (yyvsp[(4) - (5)].node)); ;} break; case 1117: -#line 3405 "third_party/libpg_query/grammar/statements/select.y" +#line 3406 "third_party/libpg_query/grammar/statements/select.y" { PGNamedArgExpr *na = makeNode(PGNamedArgExpr); na->name = (yyvsp[(1) - (3)].str); @@ -28710,320 +28696,320 @@ YYLTYPE yylloc; break; case 1118: -#line 3415 "third_party/libpg_query/grammar/statements/select.y" +#line 3416 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; case 1119: -#line 3416 "third_party/libpg_query/grammar/statements/select.y" +#line 3417 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; case 1120: -#line 3420 "third_party/libpg_query/grammar/statements/select.y" +#line 3421 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; case 1121: -#line 3421 "third_party/libpg_query/grammar/statements/select.y" +#line 3422 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; case 1122: -#line 3426 "third_party/libpg_query/grammar/statements/select.y" +#line 3427 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); ;} break; case 1123: -#line 3432 "third_party/libpg_query/grammar/statements/select.y" +#line 3433 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].list)); ;} break; case 1124: -#line 3433 "third_party/libpg_query/grammar/statements/select.y" +#line 3434 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); ;} break; case 1125: -#line 3438 "third_party/libpg_query/grammar/statements/select.y" +#line 3439 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; case 1126: -#line 3439 "third_party/libpg_query/grammar/statements/select.y" +#line 3440 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; case 1127: -#line 3444 "third_party/libpg_query/grammar/statements/select.y" +#line 3445 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; case 1128: -#line 3445 "third_party/libpg_query/grammar/statements/select.y" +#line 3446 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NULL; ;} break; case 1129: -#line 3448 "third_party/libpg_query/grammar/statements/select.y" +#line 3449 "third_party/libpg_query/grammar/statements/select.y" { (yyval.subquerytype) = PG_ANY_SUBLINK; ;} break; case 1130: -#line 3449 "third_party/libpg_query/grammar/statements/select.y" +#line 3450 "third_party/libpg_query/grammar/statements/select.y" { (yyval.subquerytype) = PG_ANY_SUBLINK; ;} break; case 1131: -#line 3450 "third_party/libpg_query/grammar/statements/select.y" +#line 3451 "third_party/libpg_query/grammar/statements/select.y" { (yyval.subquerytype) = PG_ALL_SUBLINK; ;} break; case 1132: -#line 3453 "third_party/libpg_query/grammar/statements/select.y" +#line 3454 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; case 1133: -#line 3454 "third_party/libpg_query/grammar/statements/select.y" +#line 3455 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (char*) (yyvsp[(1) - (1)].conststr); ;} break; case 1134: -#line 3457 "third_party/libpg_query/grammar/statements/select.y" +#line 3458 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = "+"; ;} break; case 1135: -#line 3458 "third_party/libpg_query/grammar/statements/select.y" +#line 3459 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = "-"; ;} break; case 1136: -#line 3459 "third_party/libpg_query/grammar/statements/select.y" +#line 3460 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = "*"; ;} break; case 1137: -#line 3460 "third_party/libpg_query/grammar/statements/select.y" +#line 3461 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = "/"; ;} break; case 1138: -#line 3461 "third_party/libpg_query/grammar/statements/select.y" +#line 3462 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = "//"; ;} break; case 1139: -#line 3462 "third_party/libpg_query/grammar/statements/select.y" +#line 3463 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = "%"; ;} break; case 1140: -#line 3463 "third_party/libpg_query/grammar/statements/select.y" +#line 3464 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = "^"; ;} break; case 1141: -#line 3464 "third_party/libpg_query/grammar/statements/select.y" +#line 3465 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = "**"; ;} break; case 1142: -#line 3465 "third_party/libpg_query/grammar/statements/select.y" +#line 3466 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = "<"; ;} break; case 1143: -#line 3466 "third_party/libpg_query/grammar/statements/select.y" +#line 3467 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = ">"; ;} break; case 1144: -#line 3467 "third_party/libpg_query/grammar/statements/select.y" +#line 3468 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = "="; ;} break; case 1145: -#line 3468 "third_party/libpg_query/grammar/statements/select.y" +#line 3469 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = "<="; ;} break; case 1146: -#line 3469 "third_party/libpg_query/grammar/statements/select.y" +#line 3470 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = ">="; ;} break; case 1147: -#line 3470 "third_party/libpg_query/grammar/statements/select.y" +#line 3471 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = "<>"; ;} break; case 1148: -#line 3474 "third_party/libpg_query/grammar/statements/select.y" +#line 3475 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; case 1149: -#line 3476 "third_party/libpg_query/grammar/statements/select.y" +#line 3477 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; case 1150: -#line 3481 "third_party/libpg_query/grammar/statements/select.y" +#line 3482 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; case 1151: -#line 3483 "third_party/libpg_query/grammar/statements/select.y" +#line 3484 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; case 1152: -#line 3488 "third_party/libpg_query/grammar/statements/select.y" +#line 3489 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; case 1153: -#line 3490 "third_party/libpg_query/grammar/statements/select.y" +#line 3491 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; case 1154: -#line 3492 "third_party/libpg_query/grammar/statements/select.y" +#line 3493 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeString("~~")); ;} break; case 1155: -#line 3494 "third_party/libpg_query/grammar/statements/select.y" +#line 3495 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeString("!~~")); ;} break; case 1156: -#line 3496 "third_party/libpg_query/grammar/statements/select.y" +#line 3497 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeString("~~~")); ;} break; case 1157: -#line 3498 "third_party/libpg_query/grammar/statements/select.y" +#line 3499 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeString("!~~~")); ;} break; case 1158: -#line 3500 "third_party/libpg_query/grammar/statements/select.y" +#line 3501 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeString("~~*")); ;} break; case 1159: -#line 3502 "third_party/libpg_query/grammar/statements/select.y" +#line 3503 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeString("!~~*")); ;} break; case 1160: -#line 3516 "third_party/libpg_query/grammar/statements/select.y" +#line 3517 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; case 1161: -#line 3518 "third_party/libpg_query/grammar/statements/select.y" +#line 3519 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lcons(makeString((yyvsp[(1) - (3)].str)), (yyvsp[(3) - (3)].list)); ;} break; case 1162: -#line 3523 "third_party/libpg_query/grammar/statements/select.y" +#line 3524 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; case 1163: -#line 3527 "third_party/libpg_query/grammar/statements/select.y" +#line 3528 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; case 1164: -#line 3534 "third_party/libpg_query/grammar/statements/select.y" +#line 3535 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; case 1165: -#line 3539 "third_party/libpg_query/grammar/statements/select.y" +#line 3540 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; case 1166: -#line 3545 "third_party/libpg_query/grammar/statements/select.y" +#line 3546 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; case 1167: -#line 3549 "third_party/libpg_query/grammar/statements/select.y" +#line 3550 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; case 1168: -#line 3556 "third_party/libpg_query/grammar/statements/select.y" +#line 3557 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; case 1169: -#line 3561 "third_party/libpg_query/grammar/statements/select.y" +#line 3562 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; case 1170: -#line 3568 "third_party/libpg_query/grammar/statements/select.y" +#line 3569 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; case 1171: -#line 3572 "third_party/libpg_query/grammar/statements/select.y" +#line 3573 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NULL; ;} break; case 1172: -#line 3581 "third_party/libpg_query/grammar/statements/select.y" +#line 3582 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; case 1173: -#line 3585 "third_party/libpg_query/grammar/statements/select.y" +#line 3586 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; case 1174: -#line 3591 "third_party/libpg_query/grammar/statements/select.y" +#line 3592 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; case 1175: -#line 3595 "third_party/libpg_query/grammar/statements/select.y" +#line 3596 "third_party/libpg_query/grammar/statements/select.y" { PGNamedArgExpr *na = makeNode(PGNamedArgExpr); na->name = (yyvsp[(1) - (3)].str); @@ -29035,7 +29021,7 @@ YYLTYPE yylloc; break; case 1176: -#line 3604 "third_party/libpg_query/grammar/statements/select.y" +#line 3605 "third_party/libpg_query/grammar/statements/select.y" { PGNamedArgExpr *na = makeNode(PGNamedArgExpr); na->name = (yyvsp[(1) - (3)].str); @@ -29047,140 +29033,140 @@ YYLTYPE yylloc; break; case 1177: -#line 3614 "third_party/libpg_query/grammar/statements/select.y" +#line 3615 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].typnam)); ;} break; case 1178: -#line 3615 "third_party/libpg_query/grammar/statements/select.y" +#line 3616 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].typnam)); ;} break; case 1179: -#line 3620 "third_party/libpg_query/grammar/statements/select.y" +#line 3621 "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 1180: -#line 3623 "third_party/libpg_query/grammar/statements/select.y" +#line 3624 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; case 1181: -#line 3630 "third_party/libpg_query/grammar/statements/select.y" +#line 3631 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; case 1182: -#line 3631 "third_party/libpg_query/grammar/statements/select.y" +#line 3632 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (char*) "year"; ;} break; case 1183: -#line 3632 "third_party/libpg_query/grammar/statements/select.y" +#line 3633 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (char*) "month"; ;} break; case 1184: -#line 3633 "third_party/libpg_query/grammar/statements/select.y" +#line 3634 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (char*) "day"; ;} break; case 1185: -#line 3634 "third_party/libpg_query/grammar/statements/select.y" +#line 3635 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (char*) "hour"; ;} break; case 1186: -#line 3635 "third_party/libpg_query/grammar/statements/select.y" +#line 3636 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (char*) "minute"; ;} break; case 1187: -#line 3636 "third_party/libpg_query/grammar/statements/select.y" +#line 3637 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (char*) "second"; ;} break; case 1188: -#line 3637 "third_party/libpg_query/grammar/statements/select.y" +#line 3638 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (char*) "millisecond"; ;} break; case 1189: -#line 3638 "third_party/libpg_query/grammar/statements/select.y" +#line 3639 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (char*) "microsecond"; ;} break; case 1190: -#line 3639 "third_party/libpg_query/grammar/statements/select.y" +#line 3640 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (char*) "week"; ;} break; case 1191: -#line 3640 "third_party/libpg_query/grammar/statements/select.y" +#line 3641 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (char*) "quarter"; ;} break; case 1192: -#line 3641 "third_party/libpg_query/grammar/statements/select.y" +#line 3642 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (char*) "decade"; ;} break; case 1193: -#line 3642 "third_party/libpg_query/grammar/statements/select.y" +#line 3643 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (char*) "century"; ;} break; case 1194: -#line 3643 "third_party/libpg_query/grammar/statements/select.y" +#line 3644 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (char*) "millennium"; ;} break; case 1195: -#line 3644 "third_party/libpg_query/grammar/statements/select.y" +#line 3645 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; case 1196: -#line 3655 "third_party/libpg_query/grammar/statements/select.y" +#line 3656 "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 1197: -#line 3659 "third_party/libpg_query/grammar/statements/select.y" +#line 3660 "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 1198: -#line 3666 "third_party/libpg_query/grammar/statements/select.y" +#line 3667 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; case 1199: -#line 3672 "third_party/libpg_query/grammar/statements/select.y" +#line 3673 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); ;} break; case 1200: -#line 3673 "third_party/libpg_query/grammar/statements/select.y" +#line 3674 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; case 1201: -#line 3690 "third_party/libpg_query/grammar/statements/select.y" +#line 3691 "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 1202: -#line 3694 "third_party/libpg_query/grammar/statements/select.y" +#line 3695 "third_party/libpg_query/grammar/statements/select.y" { /* not legal per SQL99, but might as well allow it */ (yyval.list) = list_make3((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yyvsp[(2) - (3)].node)); @@ -29188,14 +29174,14 @@ YYLTYPE yylloc; break; case 1203: -#line 3699 "third_party/libpg_query/grammar/statements/select.y" +#line 3700 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make2((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node)); ;} break; case 1204: -#line 3703 "third_party/libpg_query/grammar/statements/select.y" +#line 3704 "third_party/libpg_query/grammar/statements/select.y" { /* * Since there are no cases where this syntax allows @@ -29213,44 +29199,44 @@ YYLTYPE yylloc; break; case 1205: -#line 3718 "third_party/libpg_query/grammar/statements/select.y" +#line 3719 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; case 1206: -#line 3722 "third_party/libpg_query/grammar/statements/select.y" +#line 3723 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; case 1207: -#line 3726 "third_party/libpg_query/grammar/statements/select.y" +#line 3727 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; case 1208: -#line 3729 "third_party/libpg_query/grammar/statements/select.y" +#line 3730 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; case 1209: -#line 3732 "third_party/libpg_query/grammar/statements/select.y" +#line 3733 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(3) - (3)].list), (yyvsp[(1) - (3)].node)); ;} break; case 1210: -#line 3733 "third_party/libpg_query/grammar/statements/select.y" +#line 3734 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(2) - (2)].list); ;} break; case 1211: -#line 3734 "third_party/libpg_query/grammar/statements/select.y" +#line 3735 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; case 1212: -#line 3738 "third_party/libpg_query/grammar/statements/select.y" +#line 3739 "third_party/libpg_query/grammar/statements/select.y" { PGSubLink *n = makeNode(PGSubLink); n->subselect = (yyvsp[(1) - (1)].node); @@ -29260,17 +29246,17 @@ YYLTYPE yylloc; break; case 1213: -#line 3744 "third_party/libpg_query/grammar/statements/select.y" +#line 3745 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *)(yyvsp[(2) - (3)].list); ;} break; case 1215: -#line 3746 "third_party/libpg_query/grammar/statements/select.y" +#line 3747 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *)(yyvsp[(1) - (1)].node); ;} break; case 1216: -#line 3757 "third_party/libpg_query/grammar/statements/select.y" +#line 3758 "third_party/libpg_query/grammar/statements/select.y" { PGCaseExpr *c = makeNode(PGCaseExpr); c->casetype = InvalidOid; /* not analyzed yet */ @@ -29283,17 +29269,17 @@ YYLTYPE yylloc; break; case 1217: -#line 3770 "third_party/libpg_query/grammar/statements/select.y" +#line 3771 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; case 1218: -#line 3771 "third_party/libpg_query/grammar/statements/select.y" +#line 3772 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;} break; case 1219: -#line 3776 "third_party/libpg_query/grammar/statements/select.y" +#line 3777 "third_party/libpg_query/grammar/statements/select.y" { PGCaseWhen *w = makeNode(PGCaseWhen); w->expr = (PGExpr *) (yyvsp[(2) - (4)].node); @@ -29304,58 +29290,58 @@ YYLTYPE yylloc; break; case 1220: -#line 3786 "third_party/libpg_query/grammar/statements/select.y" +#line 3787 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; case 1221: -#line 3787 "third_party/libpg_query/grammar/statements/select.y" +#line 3788 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = NULL; ;} break; case 1222: -#line 3790 "third_party/libpg_query/grammar/statements/select.y" +#line 3791 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; case 1223: -#line 3791 "third_party/libpg_query/grammar/statements/select.y" +#line 3792 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = NULL; ;} break; case 1224: -#line 3795 "third_party/libpg_query/grammar/statements/select.y" +#line 3796 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; case 1225: -#line 3796 "third_party/libpg_query/grammar/statements/select.y" +#line 3797 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; case 1226: -#line 3800 "third_party/libpg_query/grammar/statements/select.y" +#line 3801 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeColumnRef((yyvsp[(1) - (1)].str), NIL, (yylsp[(1) - (1)]), yyscanner); ;} break; case 1227: -#line 3806 "third_party/libpg_query/grammar/statements/select.y" +#line 3807 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeColumnRef((yyvsp[(1) - (1)].str), NIL, (yylsp[(1) - (1)]), yyscanner); ;} break; case 1228: -#line 3810 "third_party/libpg_query/grammar/statements/select.y" +#line 3811 "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 1229: -#line 3817 "third_party/libpg_query/grammar/statements/select.y" +#line 3818 "third_party/libpg_query/grammar/statements/select.y" { PGAIndices *ai = makeNode(PGAIndices); ai->is_slice = false; @@ -29366,7 +29352,7 @@ YYLTYPE yylloc; break; case 1230: -#line 3825 "third_party/libpg_query/grammar/statements/select.y" +#line 3826 "third_party/libpg_query/grammar/statements/select.y" { PGAIndices *ai = makeNode(PGAIndices); ai->is_slice = true; @@ -29377,7 +29363,7 @@ YYLTYPE yylloc; break; case 1231: -#line 3832 "third_party/libpg_query/grammar/statements/select.y" +#line 3833 "third_party/libpg_query/grammar/statements/select.y" { PGAIndices *ai = makeNode(PGAIndices); ai->is_slice = true; @@ -29389,7 +29375,7 @@ YYLTYPE yylloc; break; case 1232: -#line 3840 "third_party/libpg_query/grammar/statements/select.y" +#line 3841 "third_party/libpg_query/grammar/statements/select.y" { PGAIndices *ai = makeNode(PGAIndices); ai->is_slice = true; @@ -29400,42 +29386,42 @@ YYLTYPE yylloc; break; case 1233: -#line 3850 "third_party/libpg_query/grammar/statements/select.y" +#line 3851 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; case 1234: -#line 3851 "third_party/libpg_query/grammar/statements/select.y" +#line 3852 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = NULL; ;} break; case 1235: -#line 3856 "third_party/libpg_query/grammar/statements/select.y" +#line 3857 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; case 1236: -#line 3857 "third_party/libpg_query/grammar/statements/select.y" +#line 3858 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;} break; case 1237: -#line 3861 "third_party/libpg_query/grammar/statements/select.y" +#line 3862 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NULL; ;} break; case 1238: -#line 3862 "third_party/libpg_query/grammar/statements/select.y" +#line 3863 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(NULL); ;} break; case 1239: -#line 3863 "third_party/libpg_query/grammar/statements/select.y" +#line 3864 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; case 1240: -#line 3868 "third_party/libpg_query/grammar/statements/select.y" +#line 3869 "third_party/libpg_query/grammar/statements/select.y" { if ((yyvsp[(3) - (3)].list)) { PGFuncCall *n = makeFuncCall(list_make1(makeString((yyvsp[(2) - (3)].str))), (yyvsp[(3) - (3)].list)->head->data.ptr_value ? (yyvsp[(3) - (3)].list) : NULL, (yylsp[(2) - (3)])); @@ -29447,7 +29433,7 @@ YYLTYPE yylloc; break; case 1241: -#line 3877 "third_party/libpg_query/grammar/statements/select.y" +#line 3878 "third_party/libpg_query/grammar/statements/select.y" { PGAIndices *ai = makeNode(PGAIndices); ai->is_slice = false; @@ -29458,7 +29444,7 @@ YYLTYPE yylloc; break; case 1242: -#line 3885 "third_party/libpg_query/grammar/statements/select.y" +#line 3886 "third_party/libpg_query/grammar/statements/select.y" { PGAIndices *ai = makeNode(PGAIndices); ai->is_slice = true; @@ -29469,7 +29455,7 @@ YYLTYPE yylloc; break; case 1243: -#line 3892 "third_party/libpg_query/grammar/statements/select.y" +#line 3893 "third_party/libpg_query/grammar/statements/select.y" { PGAIndices *ai = makeNode(PGAIndices); ai->is_slice = true; @@ -29481,7 +29467,7 @@ YYLTYPE yylloc; break; case 1244: -#line 3901 "third_party/libpg_query/grammar/statements/select.y" +#line 3902 "third_party/libpg_query/grammar/statements/select.y" { PGAIndices *ai = makeNode(PGAIndices); ai->is_slice = true; @@ -29492,47 +29478,47 @@ YYLTYPE yylloc; break; case 1245: -#line 3916 "third_party/libpg_query/grammar/statements/select.y" +#line 3917 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; case 1246: -#line 3917 "third_party/libpg_query/grammar/statements/select.y" +#line 3918 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;} break; case 1249: -#line 3933 "third_party/libpg_query/grammar/statements/select.y" +#line 3934 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; case 1250: -#line 3934 "third_party/libpg_query/grammar/statements/select.y" +#line 3935 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; case 1251: -#line 3938 "third_party/libpg_query/grammar/statements/select.y" +#line 3939 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].target)); ;} break; case 1252: -#line 3939 "third_party/libpg_query/grammar/statements/select.y" +#line 3940 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].target)); ;} break; case 1253: -#line 3943 "third_party/libpg_query/grammar/statements/select.y" +#line 3944 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; case 1254: -#line 3944 "third_party/libpg_query/grammar/statements/select.y" +#line 3945 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; case 1255: -#line 3948 "third_party/libpg_query/grammar/statements/select.y" +#line 3949 "third_party/libpg_query/grammar/statements/select.y" { (yyval.target) = makeNode(PGResTarget); (yyval.target)->name = (yyvsp[(3) - (3)].str); @@ -29543,7 +29529,7 @@ YYLTYPE yylloc; break; case 1256: -#line 3964 "third_party/libpg_query/grammar/statements/select.y" +#line 3965 "third_party/libpg_query/grammar/statements/select.y" { (yyval.target) = makeNode(PGResTarget); (yyval.target)->name = (yyvsp[(2) - (2)].str); @@ -29554,7 +29540,7 @@ YYLTYPE yylloc; break; case 1257: -#line 3972 "third_party/libpg_query/grammar/statements/select.y" +#line 3973 "third_party/libpg_query/grammar/statements/select.y" { (yyval.target) = makeNode(PGResTarget); (yyval.target)->name = NULL; @@ -29565,7 +29551,7 @@ YYLTYPE yylloc; break; case 1258: -#line 3980 "third_party/libpg_query/grammar/statements/select.y" +#line 3981 "third_party/libpg_query/grammar/statements/select.y" { (yyval.target) = makeNode(PGResTarget); (yyval.target)->name = (yyvsp[(1) - (3)].str); @@ -29576,191 +29562,191 @@ YYLTYPE yylloc; break; case 1259: -#line 3989 "third_party/libpg_query/grammar/statements/select.y" +#line 3990 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; case 1260: -#line 3990 "third_party/libpg_query/grammar/statements/select.y" +#line 3991 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(2) - (2)].list)); ;} break; case 1261: -#line 3995 "third_party/libpg_query/grammar/statements/select.y" +#line 3996 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].str)); ;} break; case 1262: -#line 3999 "third_party/libpg_query/grammar/statements/select.y" +#line 4000 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].str)); ;} break; case 1263: -#line 4005 "third_party/libpg_query/grammar/statements/select.y" +#line 4006 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].list)); ;} break; case 1264: -#line 4007 "third_party/libpg_query/grammar/statements/select.y" +#line 4008 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); ;} break; case 1265: -#line 4011 "third_party/libpg_query/grammar/statements/select.y" +#line 4012 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; case 1266: -#line 4012 "third_party/libpg_query/grammar/statements/select.y" +#line 4013 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; case 1267: -#line 4016 "third_party/libpg_query/grammar/statements/select.y" +#line 4017 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; case 1268: -#line 4017 "third_party/libpg_query/grammar/statements/select.y" +#line 4018 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NULL; ;} break; case 1269: -#line 4020 "third_party/libpg_query/grammar/statements/select.y" +#line 4021 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make2((yyvsp[(1) - (3)].node), makeString((yyvsp[(3) - (3)].str))); ;} break; case 1270: -#line 4024 "third_party/libpg_query/grammar/statements/select.y" +#line 4025 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].list)); ;} break; case 1271: -#line 4025 "third_party/libpg_query/grammar/statements/select.y" +#line 4026 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); ;} break; case 1272: -#line 4029 "third_party/libpg_query/grammar/statements/select.y" +#line 4030 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; case 1273: -#line 4030 "third_party/libpg_query/grammar/statements/select.y" +#line 4031 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; case 1274: -#line 4033 "third_party/libpg_query/grammar/statements/select.y" +#line 4034 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; case 1275: -#line 4034 "third_party/libpg_query/grammar/statements/select.y" +#line 4035 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(2) - (2)].list)); ;} break; case 1276: -#line 4035 "third_party/libpg_query/grammar/statements/select.y" +#line 4036 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NULL; ;} break; case 1277: -#line 4038 "third_party/libpg_query/grammar/statements/select.y" +#line 4039 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make2((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].str)); ;} break; case 1278: -#line 4042 "third_party/libpg_query/grammar/statements/select.y" +#line 4043 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].list)); ;} break; case 1279: -#line 4043 "third_party/libpg_query/grammar/statements/select.y" +#line 4044 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); ;} break; case 1280: -#line 4047 "third_party/libpg_query/grammar/statements/select.y" +#line 4048 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; case 1281: -#line 4048 "third_party/libpg_query/grammar/statements/select.y" +#line 4049 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; case 1282: -#line 4050 "third_party/libpg_query/grammar/statements/select.y" +#line 4051 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; case 1283: -#line 4051 "third_party/libpg_query/grammar/statements/select.y" +#line 4052 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(2) - (2)].list)); ;} break; case 1284: -#line 4052 "third_party/libpg_query/grammar/statements/select.y" +#line 4053 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NULL; ;} break; case 1285: -#line 4062 "third_party/libpg_query/grammar/statements/select.y" +#line 4063 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].range)); ;} break; case 1286: -#line 4063 "third_party/libpg_query/grammar/statements/select.y" +#line 4064 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].range)); ;} break; case 1287: -#line 4068 "third_party/libpg_query/grammar/statements/select.y" +#line 4069 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; case 1288: -#line 4070 "third_party/libpg_query/grammar/statements/select.y" +#line 4071 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), makeString((yyvsp[(3) - (3)].str))); ;} break; case 1289: -#line 4075 "third_party/libpg_query/grammar/statements/select.y" +#line 4076 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; case 1290: -#line 4076 "third_party/libpg_query/grammar/statements/select.y" +#line 4077 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; case 1291: -#line 4080 "third_party/libpg_query/grammar/statements/select.y" +#line 4081 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; case 1292: -#line 4081 "third_party/libpg_query/grammar/statements/select.y" +#line 4082 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; case 1293: -#line 4084 "third_party/libpg_query/grammar/statements/select.y" +#line 4085 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; case 1294: -#line 4096 "third_party/libpg_query/grammar/statements/select.y" +#line 4097 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; case 1295: -#line 4099 "third_party/libpg_query/grammar/statements/select.y" +#line 4100 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = check_func_name(lcons(makeString((yyvsp[(1) - (2)].str)), (yyvsp[(2) - (2)].list)), yyscanner); @@ -29768,21 +29754,21 @@ YYLTYPE yylloc; break; case 1296: -#line 4110 "third_party/libpg_query/grammar/statements/select.y" +#line 4111 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeIntConst((yyvsp[(1) - (1)].ival), (yylsp[(1) - (1)])); ;} break; case 1297: -#line 4114 "third_party/libpg_query/grammar/statements/select.y" +#line 4115 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeFloatConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); ;} break; case 1298: -#line 4118 "third_party/libpg_query/grammar/statements/select.y" +#line 4119 "third_party/libpg_query/grammar/statements/select.y" { if ((yyvsp[(2) - (2)].list)) { @@ -29797,14 +29783,14 @@ YYLTYPE yylloc; break; case 1299: -#line 4130 "third_party/libpg_query/grammar/statements/select.y" +#line 4131 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeBitStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); ;} break; case 1300: -#line 4134 "third_party/libpg_query/grammar/statements/select.y" +#line 4135 "third_party/libpg_query/grammar/statements/select.y" { /* This is a bit constant per SQL99: * Without Feature F511, "BIT data type", @@ -29816,7 +29802,7 @@ YYLTYPE yylloc; break; case 1301: -#line 4143 "third_party/libpg_query/grammar/statements/select.y" +#line 4144 "third_party/libpg_query/grammar/statements/select.y" { /* generic type 'literal' syntax */ PGTypeName *t = makeTypeNameFromNameList((yyvsp[(1) - (2)].list)); @@ -29826,7 +29812,7 @@ YYLTYPE yylloc; break; case 1302: -#line 4150 "third_party/libpg_query/grammar/statements/select.y" +#line 4151 "third_party/libpg_query/grammar/statements/select.y" { /* generic syntax with a type modifier */ PGTypeName *t = makeTypeNameFromNameList((yyvsp[(1) - (7)].list)); @@ -29867,141 +29853,141 @@ YYLTYPE yylloc; break; case 1303: -#line 4188 "third_party/libpg_query/grammar/statements/select.y" +#line 4189 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeStringConstCast((yyvsp[(2) - (2)].str), (yylsp[(2) - (2)]), (yyvsp[(1) - (2)].typnam)); ;} break; case 1304: -#line 4192 "third_party/libpg_query/grammar/statements/select.y" +#line 4193 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeIntervalNode((yyvsp[(3) - (5)].node), (yylsp[(3) - (5)]), (yyvsp[(5) - (5)].list)); ;} break; case 1305: -#line 4196 "third_party/libpg_query/grammar/statements/select.y" +#line 4197 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeIntervalNode((yyvsp[(2) - (3)].ival), (yylsp[(2) - (3)]), (yyvsp[(3) - (3)].list)); ;} break; case 1306: -#line 4200 "third_party/libpg_query/grammar/statements/select.y" +#line 4201 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeIntervalNode((yyvsp[(2) - (3)].str), (yylsp[(2) - (3)]), (yyvsp[(3) - (3)].list)); ;} break; case 1307: -#line 4204 "third_party/libpg_query/grammar/statements/select.y" +#line 4205 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeBoolAConst(true, (yylsp[(1) - (1)])); ;} break; case 1308: -#line 4208 "third_party/libpg_query/grammar/statements/select.y" +#line 4209 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeBoolAConst(false, (yylsp[(1) - (1)])); ;} break; case 1309: -#line 4212 "third_party/libpg_query/grammar/statements/select.y" +#line 4213 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeNullAConst((yylsp[(1) - (1)])); ;} break; case 1310: -#line 4217 "third_party/libpg_query/grammar/statements/select.y" +#line 4218 "third_party/libpg_query/grammar/statements/select.y" { (yyval.ival) = (yyvsp[(1) - (1)].ival); ;} break; case 1311: -#line 4234 "third_party/libpg_query/grammar/statements/select.y" +#line 4235 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; case 1312: -#line 4235 "third_party/libpg_query/grammar/statements/select.y" +#line 4236 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; case 1313: -#line 4236 "third_party/libpg_query/grammar/statements/select.y" +#line 4237 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; case 1314: -#line 4239 "third_party/libpg_query/grammar/statements/select.y" +#line 4240 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; case 1315: -#line 4240 "third_party/libpg_query/grammar/statements/select.y" +#line 4241 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; case 1316: -#line 4241 "third_party/libpg_query/grammar/statements/select.y" +#line 4242 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; case 1317: -#line 4244 "third_party/libpg_query/grammar/statements/select.y" +#line 4245 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; case 1318: -#line 4245 "third_party/libpg_query/grammar/statements/select.y" +#line 4246 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; case 1319: -#line 4246 "third_party/libpg_query/grammar/statements/select.y" +#line 4247 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; case 1320: -#line 4249 "third_party/libpg_query/grammar/statements/select.y" +#line 4250 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; case 1321: -#line 4250 "third_party/libpg_query/grammar/statements/select.y" +#line 4251 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lcons(makeString((yyvsp[(1) - (2)].str)), (yyvsp[(2) - (2)].list)); ;} break; case 1322: -#line 4254 "third_party/libpg_query/grammar/statements/select.y" +#line 4255 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeString((yyvsp[(2) - (2)].str))); ;} break; case 1323: -#line 4256 "third_party/libpg_query/grammar/statements/select.y" +#line 4257 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), makeString((yyvsp[(3) - (3)].str))); ;} break; case 1324: -#line 4260 "third_party/libpg_query/grammar/statements/select.y" +#line 4261 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; case 1325: -#line 4261 "third_party/libpg_query/grammar/statements/select.y" +#line 4262 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; case 1327: -#line 4268 "third_party/libpg_query/grammar/statements/select.y" +#line 4269 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; case 1328: -#line 4269 "third_party/libpg_query/grammar/statements/select.y" +#line 4270 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; @@ -31536,7 +31522,7 @@ YYLTYPE yylloc; /* Line 1267 of yacc.c. */ -#line 31540 "third_party/libpg_query/grammar/grammar_out.cpp" +#line 31526 "third_party/libpg_query/grammar/grammar_out.cpp" default: break; } YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); From 8de3a1c9650da251df64f604e8fc9ef8e9f3bf9c Mon Sep 17 00:00:00 2001 From: DuckDB Labs GitHub Bot Date: Sat, 4 Jan 2025 00:33:07 +0000 Subject: [PATCH 02/16] Update vendored DuckDB sources to 37e5e11c --- .../comparison_operators.cpp | 3 +- .../function/table/version/pragma_version.cpp | 6 +- .../src/include/duckdb/common/atomic_ptr.hpp | 102 ++++++++++++++++++ .../src/include/duckdb/common/fast_mem.hpp | 12 +-- .../duckdb/storage/table/column_data.hpp | 11 +- .../transform/tableref/transform_pivot.cpp | 1 + src/duckdb/src/planner/bind_context.cpp | 22 ++-- .../expression/bind_window_expression.cpp | 2 +- .../planner/binder/statement/bind_vacuum.cpp | 11 +- .../subquery/flatten_dependent_join.cpp | 3 +- src/duckdb/src/storage/table/column_data.cpp | 6 +- .../storage/table/standard_column_data.cpp | 12 ++- 12 files changed, 145 insertions(+), 46 deletions(-) create mode 100644 src/duckdb/src/include/duckdb/common/atomic_ptr.hpp diff --git a/src/duckdb/src/common/vector_operations/comparison_operators.cpp b/src/duckdb/src/common/vector_operations/comparison_operators.cpp index 8a56cdfc3..9c5c3d662 100644 --- a/src/duckdb/src/common/vector_operations/comparison_operators.cpp +++ b/src/duckdb/src/common/vector_operations/comparison_operators.cpp @@ -223,7 +223,8 @@ struct ComparisonExecutor { public: template static inline void Execute(Vector &left, Vector &right, Vector &result, idx_t count) { - D_ASSERT(left.GetType() == right.GetType() && result.GetType() == LogicalType::BOOLEAN); + D_ASSERT(left.GetType().InternalType() == right.GetType().InternalType() && + result.GetType() == LogicalType::BOOLEAN); // the inplace loops take the result as the last parameter switch (left.GetType().InternalType()) { case PhysicalType::BOOL: diff --git a/src/duckdb/src/function/table/version/pragma_version.cpp b/src/duckdb/src/function/table/version/pragma_version.cpp index db89e256f..246f5cbcf 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 "4-dev3921" +#define DUCKDB_PATCH_VERSION "4-dev3951" #endif #ifndef DUCKDB_MINOR_VERSION #define DUCKDB_MINOR_VERSION 1 @@ -8,10 +8,10 @@ #define DUCKDB_MAJOR_VERSION 1 #endif #ifndef DUCKDB_VERSION -#define DUCKDB_VERSION "v1.1.4-dev3921" +#define DUCKDB_VERSION "v1.1.4-dev3951" #endif #ifndef DUCKDB_SOURCE_ID -#define DUCKDB_SOURCE_ID "6c4d2a394f" +#define DUCKDB_SOURCE_ID "1342bdbf2d" #endif #include "duckdb/function/table/system_functions.hpp" #include "duckdb/main/database.hpp" diff --git a/src/duckdb/src/include/duckdb/common/atomic_ptr.hpp b/src/duckdb/src/include/duckdb/common/atomic_ptr.hpp new file mode 100644 index 000000000..da2281d87 --- /dev/null +++ b/src/duckdb/src/include/duckdb/common/atomic_ptr.hpp @@ -0,0 +1,102 @@ +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/common/atomic_ptr.hpp +// +// +//===----------------------------------------------------------------------===// + +#pragma once + +#include "duckdb/common/exception.hpp" +#include "duckdb/common/atomic.hpp" +#include "duckdb/common/shared_ptr.hpp" +#include "duckdb/common/unique_ptr.hpp" + +namespace duckdb { + +template +class atomic_ptr { // NOLINT: mimic std casing +public: + atomic_ptr() noexcept : ptr(nullptr) { + } + atomic_ptr(T *ptr_p) : ptr(ptr_p) { // NOLINT: allow implicit creation from pointer + } + atomic_ptr(T &ref) : ptr(&ref) { // NOLINT: allow implicit creation from reference + } + atomic_ptr(const unique_ptr &ptr_p) : ptr(ptr_p.get()) { // NOLINT: allow implicit creation from unique pointer + } + atomic_ptr(const shared_ptr &ptr_p) : ptr(ptr_p.get()) { // NOLINT: allow implicit creation from shared pointer + } + + void CheckValid(const T *ptr) const { + if (MemorySafety::ENABLED) { + return; + } + if (!ptr) { + throw InternalException("Attempting to dereference an optional pointer that is not set"); + } + } + + T *GetPointer() { + auto res = ptr.load(); + CheckValid(res); + return res; + } + + const T *GetPointer() const { + auto res = ptr.load(); + CheckValid(res); + return res; + } + + operator bool() const { // NOLINT: allow implicit conversion to bool + return ptr; + } + T &operator*() { + return *GetPointer(); + } + const T &operator*() const { + return *GetPointer(); + } + T *operator->() { + return GetPointer(); + } + const T *operator->() const { + return GetPointer(); + } + T *get() { // NOLINT: mimic std casing + return GetPointer(); + } + const T *get() const { // NOLINT: mimic std casing + return GetPointer(); + } + // this looks dirty - but this is the default behavior of raw pointers + T *get_mutable() const { // NOLINT: mimic std casing + return GetPointer(); + } + + void set(T &ref) { + ptr = &ref; + } + + void reset() { + ptr = nullptr; + } + + bool operator==(const atomic_ptr &rhs) const { + return ptr.load() == rhs.ptr.load(); + } + + bool operator!=(const atomic_ptr &rhs) const { + return ptr.load() != rhs.ptr.load(); + } + +private: + atomic ptr; +}; + +template +using unsafe_atomic_ptr = atomic_ptr; + +} // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/common/fast_mem.hpp b/src/duckdb/src/include/duckdb/common/fast_mem.hpp index dc2730f34..f18130862 100644 --- a/src/duckdb/src/include/duckdb/common/fast_mem.hpp +++ b/src/duckdb/src/include/duckdb/common/fast_mem.hpp @@ -11,17 +11,17 @@ #include "duckdb/common/types.hpp" template -static inline void MemcpyFixed(void *dest, const void *src) { +inline void MemcpyFixed(void *dest, const void *src) { memcpy(dest, src, SIZE); } template -static inline int MemcmpFixed(const void *str1, const void *str2) { +inline int MemcmpFixed(const void *str1, const void *str2) { return memcmp(str1, str2, SIZE); } template -static inline void MemsetFixed(void *ptr, int value) { +inline void MemsetFixed(void *ptr, int value) { memset(ptr, value, SIZE); } @@ -30,7 +30,7 @@ namespace duckdb { //! This templated memcpy is significantly faster than std::memcpy, //! but only when you are calling memcpy with a const size in a loop. //! For instance `while () { memcpy(, , const_size); ... }` -static inline void FastMemcpy(void *dest, const void *src, const size_t size) { +inline void FastMemcpy(void *dest, const void *src, const size_t size) { // LCOV_EXCL_START switch (size) { case 0: @@ -556,7 +556,7 @@ static inline void FastMemcpy(void *dest, const void *src, const size_t size) { //! This templated memcmp is significantly faster than std::memcmp, //! but only when you are calling memcmp with a const size in a loop. //! For instance `while () { memcmp(, , const_size); ... }` -static inline int FastMemcmp(const void *str1, const void *str2, const size_t size) { +inline int FastMemcmp(const void *str1, const void *str2, const size_t size) { // LCOV_EXCL_START switch (size) { case 0: @@ -695,7 +695,7 @@ static inline int FastMemcmp(const void *str1, const void *str2, const size_t si // LCOV_EXCL_STOP } -static inline void FastMemset(void *ptr, int value, size_t size) { +inline void FastMemset(void *ptr, int value, size_t size) { // LCOV_EXCL_START switch (size) { case 0: 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 2adf798d0..cbf354f37 100644 --- a/src/duckdb/src/include/duckdb/storage/table/column_data.hpp +++ b/src/duckdb/src/include/duckdb/storage/table/column_data.hpp @@ -18,6 +18,7 @@ #include "duckdb/common/mutex.hpp" #include "duckdb/common/enums/scan_vector_type.hpp" #include "duckdb/common/serializer/serialization_traits.hpp" +#include "duckdb/common/atomic_ptr.hpp" namespace duckdb { class ColumnData; @@ -81,12 +82,8 @@ class ColumnData { idx_t GetAllocationSize() const { return allocation_size; } - bool HasCompressionFunction() const { - return compression != nullptr; - } - const CompressionFunction &GetCompressionFunction() const { - D_ASSERT(HasCompressionFunction()); - return *compression; + optional_ptr GetCompressionFunction() const { + return compression.get(); } bool HasParent() const { @@ -238,7 +235,7 @@ class ColumnData { optional_ptr parent; //! The compression function used by the ColumnData //! This is empty if the segments have mixed compression or the ColumnData is empty - optional_ptr compression; + atomic_ptr compression; }; struct PersistentColumnData { diff --git a/src/duckdb/src/parser/transform/tableref/transform_pivot.cpp b/src/duckdb/src/parser/transform/tableref/transform_pivot.cpp index 3a51ba0f7..d042d881d 100644 --- a/src/duckdb/src/parser/transform/tableref/transform_pivot.cpp +++ b/src/duckdb/src/parser/transform/tableref/transform_pivot.cpp @@ -73,6 +73,7 @@ PivotColumn Transformer::TransformPivotColumn(duckdb_libpgquery::PGPivot &pivot, "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); } } diff --git a/src/duckdb/src/planner/bind_context.cpp b/src/duckdb/src/planner/bind_context.cpp index 58ddbaac6..d135ed2ae 100644 --- a/src/duckdb/src/planner/bind_context.cpp +++ b/src/duckdb/src/planner/bind_context.cpp @@ -695,14 +695,6 @@ void BindContext::AddContext(BindContext other) { } for (auto &entry : other.using_columns) { for (auto &alias : entry.second) { -#ifdef DEBUG - for (auto &other_alias : using_columns[entry.first]) { - for (auto &col : alias.get().bindings) { - D_ASSERT(std::find(other_alias.get().bindings.begin(), other_alias.get().bindings.end(), col) == - other_alias.get().bindings.end()); - } - } -#endif using_columns[entry.first].insert(alias); } } @@ -719,22 +711,22 @@ vector BindContext::GetBindingAliases() { void BindContext::RemoveContext(const vector &aliases) { for (auto &alias : aliases) { // remove the binding from any USING columns + vector removed_using_columns; for (auto &using_sets : using_columns) { for (auto &using_set_ref : using_sets.second) { auto &using_set = using_set_ref.get(); auto it = std::remove_if(using_set.bindings.begin(), using_set.bindings.end(), [&](const BindingAlias &using_alias) { return using_alias == alias; }); using_set.bindings.erase(it, using_set.bindings.end()); - if (using_set.bindings.empty()) { - throw InternalException( - "BindContext::RemoveContext - no more tables that refer to this using binding"); - } - if (using_set.primary_binding == alias) { - throw InternalException( - "BindContext::RemoveContext - cannot remove primary binding from using binding"); + if (using_set.bindings.empty() || using_set.primary_binding == alias) { + // if the using column is no longer referred to - remove it entirely + removed_using_columns.push_back(using_sets.first); } } } + for (auto &removed_col : removed_using_columns) { + using_columns.erase(removed_col); + } // remove the binding from the list of bindings auto it = std::remove_if(bindings_list.begin(), bindings_list.end(), diff --git a/src/duckdb/src/planner/binder/expression/bind_window_expression.cpp b/src/duckdb/src/planner/binder/expression/bind_window_expression.cpp index 7fcf96e69..72a6c4be2 100644 --- a/src/duckdb/src/planner/binder/expression/bind_window_expression.cpp +++ b/src/duckdb/src/planner/binder/expression/bind_window_expression.cpp @@ -155,7 +155,7 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) { return BindMacro(*macro, entry->Cast(), depth, macro_expr); } - auto name = window.GetName(); + auto name = window.alias; if (inside_window) { throw BinderException(error_context, "window function calls cannot be nested"); diff --git a/src/duckdb/src/planner/binder/statement/bind_vacuum.cpp b/src/duckdb/src/planner/binder/statement/bind_vacuum.cpp index 34b0ec56e..93e70fe5b 100644 --- a/src/duckdb/src/planner/binder/statement/bind_vacuum.cpp +++ b/src/duckdb/src/planner/binder/statement/bind_vacuum.cpp @@ -27,8 +27,9 @@ void Binder::BindVacuumTable(LogicalVacuum &vacuum, unique_ptr auto &columns = info.columns; if (columns.empty()) { // Empty means ALL columns should be vacuumed/analyzed - auto &get = ref->get->Cast(); - columns.insert(columns.end(), get.names.begin(), get.names.end()); + for (auto &col : table.GetColumns().Physical()) { + columns.push_back(col.GetName()); + } } case_insensitive_set_t column_name_set; @@ -45,7 +46,9 @@ void Binder::BindVacuumTable(LogicalVacuum &vacuum, unique_ptr auto &col = table.GetColumn(col_name); // ignore generated column if (col.Generated()) { - continue; + throw BinderException( + "cannot vacuum or analyze generated column \"%s\" - specify non-generated columns to vacuum or analyze", + col.GetName()); } non_generated_column_names.push_back(col_name); ColumnRefExpression colref(col_name, table.name); @@ -56,8 +59,6 @@ void Binder::BindVacuumTable(LogicalVacuum &vacuum, unique_ptr select_list.push_back(std::move(result.expression)); } info.columns = std::move(non_generated_column_names); - // Creating a table without any physical columns is not supported - D_ASSERT(!select_list.empty()); auto table_scan = CreatePlan(*ref); D_ASSERT(table_scan->type == LogicalOperatorType::LOGICAL_GET); diff --git a/src/duckdb/src/planner/subquery/flatten_dependent_join.cpp b/src/duckdb/src/planner/subquery/flatten_dependent_join.cpp index af79baa83..a297a7855 100644 --- a/src/duckdb/src/planner/subquery/flatten_dependent_join.cpp +++ b/src/duckdb/src/planner/subquery/flatten_dependent_join.cpp @@ -414,7 +414,7 @@ unique_ptr FlattenDependentJoins::PushDownDependentJoinInternal return plan; } } else if (join.join_type == JoinType::RIGHT) { - // left outer join + // right outer join if (!left_has_correlation) { // only right has correlation: push into right plan->children[1] = PushDownDependentJoinInternal(std::move(plan->children[1]), @@ -450,6 +450,7 @@ unique_ptr FlattenDependentJoins::PushDownDependentJoinInternal this->base_binding = left_binding; } else if (join.join_type == JoinType::RIGHT) { this->base_binding = right_binding; + delim_offset += plan->children[0]->GetColumnBindings().size(); } // add the correlated columns to the join conditions for (idx_t i = 0; i < correlated_columns.size(); i++) { diff --git a/src/duckdb/src/storage/table/column_data.cpp b/src/duckdb/src/storage/table/column_data.cpp index ac4d89464..5b4b1cafa 100644 --- a/src/duckdb/src/storage/table/column_data.cpp +++ b/src/duckdb/src/storage/table/column_data.cpp @@ -571,12 +571,12 @@ void ColumnData::UpdateCompressionFunction(SegmentLock &l, const CompressionFunc // if we have no segments - we have not set it yet, so assign it // if we have segments, the compression is mixed, so ignore it if (data.GetSegmentCount(l) == 0) { - compression = function; + compression.set(function); } } else if (compression->type != function.type) { // we already have compression set - and we are adding a segment with a different compression // compression in the segment is mixed - clear the compression pointer - compression = nullptr; + compression.reset(); } } @@ -632,7 +632,7 @@ unique_ptr ColumnData::Checkpoint(RowGroup &row_group, Co checkpointer.FinalizeCheckpoint(data.MoveSegments(l)); // reset the compression function - compression = nullptr; + compression.reset(); // replace the old tree with the new one auto new_segments = checkpoint_state->new_tree.MoveSegments(); for (auto &new_segment : new_segments) { diff --git a/src/duckdb/src/storage/table/standard_column_data.cpp b/src/duckdb/src/storage/table/standard_column_data.cpp index d09f0904c..506d04827 100644 --- a/src/duckdb/src/storage/table/standard_column_data.cpp +++ b/src/duckdb/src/storage/table/standard_column_data.cpp @@ -83,8 +83,10 @@ void StandardColumnData::Filter(TransactionData transaction, idx_t vector_index, SelectionVector &sel, idx_t &count, const TableFilter &filter) { // check if we can do a specialized select // the compression functions need to support this - bool has_filter = HasCompressionFunction() && GetCompressionFunction().filter; - bool validity_has_filter = validity.HasCompressionFunction() && validity.GetCompressionFunction().filter; + auto compression = GetCompressionFunction(); + bool has_filter = compression && compression->filter; + auto validity_compression = validity.GetCompressionFunction(); + bool validity_has_filter = validity_compression && validity_compression->filter; auto target_count = GetVectorCount(vector_index); auto scan_type = GetVectorScanType(state, target_count, result); bool scan_entire_vector = scan_type == ScanVectorType::SCAN_ENTIRE_VECTOR; @@ -102,8 +104,10 @@ void StandardColumnData::Select(TransactionData transaction, idx_t vector_index, SelectionVector &sel, idx_t sel_count) { // check if we can do a specialized select // the compression functions need to support this - bool has_select = HasCompressionFunction() && GetCompressionFunction().select; - bool validity_has_select = validity.HasCompressionFunction() && validity.GetCompressionFunction().select; + auto compression = GetCompressionFunction(); + bool has_select = compression && compression->select; + auto validity_compression = validity.GetCompressionFunction(); + bool validity_has_select = validity_compression && validity_compression->select; auto target_count = GetVectorCount(vector_index); auto scan_type = GetVectorScanType(state, target_count, result); bool scan_entire_vector = scan_type == ScanVectorType::SCAN_ENTIRE_VECTOR; From f6c8d908fed98138265d0b3166a9d0cca6269361 Mon Sep 17 00:00:00 2001 From: Gabor Szarnyas Date: Sat, 4 Jan 2025 08:46:36 +0100 Subject: [PATCH 03/16] Update year in license file to 2025 --- LICENSE | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/LICENSE b/LICENSE index 43eec6098..4e1fbb769 100644 --- a/LICENSE +++ b/LICENSE @@ -1,4 +1,4 @@ -Copyright 2018-2024 Stichting DuckDB Foundation +Copyright 2018-2025 Stichting DuckDB Foundation Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: From c2eee7cbd873c4b5b359ccd54a0bc99fb65b3fad Mon Sep 17 00:00:00 2001 From: DuckDB Labs GitHub Bot Date: Sun, 5 Jan 2025 00:37:09 +0000 Subject: [PATCH 04/16] Update vendored DuckDB sources to 8de3a1c9 --- .../table/system/duckdb_extensions.cpp | 2 +- .../function/table/version/pragma_version.cpp | 6 ++--- .../include/duckdb/main/extension_helper.hpp | 4 +++ .../src/main/extension/extension_install.cpp | 26 ++++++++++++++----- 4 files changed, 27 insertions(+), 11 deletions(-) diff --git a/src/duckdb/src/function/table/system/duckdb_extensions.cpp b/src/duckdb/src/function/table/system/duckdb_extensions.cpp index c61fa7431..64d26dea9 100644 --- a/src/duckdb/src/function/table/system/duckdb_extensions.cpp +++ b/src/duckdb/src/function/table/system/duckdb_extensions.cpp @@ -97,7 +97,7 @@ unique_ptr DuckDBExtensionsInit(ClientContext &context // Secondly we scan all installed extensions and their install info #ifndef WASM_LOADABLE_EXTENSIONS - auto ext_directory = ExtensionHelper::ExtensionDirectory(context); + auto ext_directory = ExtensionHelper::GetExtensionDirectoryPath(context); fs.ListFiles(ext_directory, [&](const string &path, bool is_directory) { if (!StringUtil::EndsWith(path, ".duckdb_extension")) { return; diff --git a/src/duckdb/src/function/table/version/pragma_version.cpp b/src/duckdb/src/function/table/version/pragma_version.cpp index 246f5cbcf..c68f78fca 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 "4-dev3951" +#define DUCKDB_PATCH_VERSION "4-dev3961" #endif #ifndef DUCKDB_MINOR_VERSION #define DUCKDB_MINOR_VERSION 1 @@ -8,10 +8,10 @@ #define DUCKDB_MAJOR_VERSION 1 #endif #ifndef DUCKDB_VERSION -#define DUCKDB_VERSION "v1.1.4-dev3951" +#define DUCKDB_VERSION "v1.1.4-dev3961" #endif #ifndef DUCKDB_SOURCE_ID -#define DUCKDB_SOURCE_ID "1342bdbf2d" +#define DUCKDB_SOURCE_ID "4488c61ee7" #endif #include "duckdb/function/table/system_functions.hpp" #include "duckdb/main/database.hpp" diff --git a/src/duckdb/src/include/duckdb/main/extension_helper.hpp b/src/duckdb/src/include/duckdb/main/extension_helper.hpp index 829a225bc..7a7c3ed9e 100644 --- a/src/duckdb/src/include/duckdb/main/extension_helper.hpp +++ b/src/duckdb/src/include/duckdb/main/extension_helper.hpp @@ -123,6 +123,10 @@ class ExtensionHelper { static string ExtensionDirectory(ClientContext &context); static string ExtensionDirectory(DatabaseInstance &db, FileSystem &fs); + // Get the extension directory path + static string GetExtensionDirectoryPath(ClientContext &context); + static string GetExtensionDirectoryPath(DatabaseInstance &db, FileSystem &fs); + static bool CheckExtensionSignature(FileHandle &handle, ParsedExtensionMetaData &parsed_metadata, const bool allow_community_extensions); static ParsedExtensionMetaData ParseExtensionMetaData(const char *metadata) noexcept; diff --git a/src/duckdb/src/main/extension/extension_install.cpp b/src/duckdb/src/main/extension/extension_install.cpp index 1258d95ea..5675bb9ac 100644 --- a/src/duckdb/src/main/extension/extension_install.cpp +++ b/src/duckdb/src/main/extension/extension_install.cpp @@ -70,10 +70,13 @@ duckdb::string ExtensionHelper::DefaultExtensionFolder(FileSystem &fs) { return res; } -string ExtensionHelper::ExtensionDirectory(DatabaseInstance &db, FileSystem &fs) { -#ifdef WASM_LOADABLE_EXTENSIONS - throw PermissionException("ExtensionDirectory functionality is not supported in duckdb-wasm"); -#endif +string ExtensionHelper::GetExtensionDirectoryPath(ClientContext &context) { + auto &db = DatabaseInstance::GetDatabase(context); + auto &fs = FileSystem::GetFileSystem(context); + return GetExtensionDirectoryPath(db, fs); +} + +string ExtensionHelper::GetExtensionDirectoryPath(DatabaseInstance &db, FileSystem &fs) { string extension_directory; auto &config = db.config; if (!config.options.extension_directory.empty()) { // create the extension directory if not present @@ -83,10 +86,19 @@ string ExtensionHelper::ExtensionDirectory(DatabaseInstance &db, FileSystem &fs) } else { // otherwise default to home extension_directory = DefaultExtensionFolder(fs); } + + extension_directory = fs.ConvertSeparators(extension_directory); + // expand ~ in extension directory + extension_directory = fs.ExpandPath(extension_directory); + return extension_directory; +} + +string ExtensionHelper::ExtensionDirectory(DatabaseInstance &db, FileSystem &fs) { +#ifdef WASM_LOADABLE_EXTENSIONS + throw PermissionException("ExtensionDirectory functionality is not supported in duckdb-wasm"); +#endif + string extension_directory = GetExtensionDirectoryPath(db, fs); { - extension_directory = fs.ConvertSeparators(extension_directory); - // expand ~ in extension directory - extension_directory = fs.ExpandPath(extension_directory); if (!fs.DirectoryExists(extension_directory)) { auto sep = fs.PathSeparator(extension_directory); auto splits = StringUtil::Split(extension_directory, sep); From 0e3a5cb01ccce5d59530305914f2f6078f9ff465 Mon Sep 17 00:00:00 2001 From: DuckDB Labs GitHub Bot Date: Tue, 7 Jan 2025 00:34:20 +0000 Subject: [PATCH 05/16] Update vendored DuckDB sources to c2eee7cb --- src/duckdb/src/common/extra_type_info.cpp | 69 ++++- .../src/common/progress_bar/progress_bar.cpp | 2 - src/duckdb/src/common/types.cpp | 86 +++--- .../persistent/physical_copy_database.cpp | 1 + .../src/execution/physical_plan/plan_get.cpp | 5 +- .../src/function/table/arrow_conversion.cpp | 22 +- .../function/table/version/pragma_version.cpp | 6 +- .../catalog_entry/table_catalog_entry.hpp | 5 + .../duckdb/common/extension_type_info.hpp | 19 ++ .../include/duckdb/common/extra_type_info.hpp | 12 +- .../src/include/duckdb/common/types.hpp | 11 +- .../include/duckdb/function/table/arrow.hpp | 3 +- .../duckdb/planner/operator/logical_get.hpp | 10 +- .../include/duckdb/planner/table_binding.hpp | 5 +- src/duckdb/src/main/config.cpp | 5 +- .../src/main/settings/custom_settings.cpp | 4 + .../transform/helpers/transform_typename.cpp | 7 +- .../planner/binder/statement/bind_create.cpp | 249 +++++++++--------- .../planner/binder/statement/bind_delete.cpp | 2 +- .../planner/binder/statement/bind_update.cpp | 2 +- .../binder/tableref/bind_basetableref.cpp | 5 +- .../expression/bound_window_expression.cpp | 2 +- .../src/planner/operator/logical_get.cpp | 8 +- src/duckdb/src/planner/table_binding.cpp | 9 +- .../storage/serialization/serialize_types.cpp | 25 +- 25 files changed, 343 insertions(+), 231 deletions(-) create mode 100644 src/duckdb/src/include/duckdb/common/extension_type_info.hpp diff --git a/src/duckdb/src/common/extra_type_info.cpp b/src/duckdb/src/common/extra_type_info.cpp index 54f03447c..a32129fd2 100644 --- a/src/duckdb/src/common/extra_type_info.cpp +++ b/src/duckdb/src/common/extra_type_info.cpp @@ -10,21 +10,12 @@ namespace duckdb { //===--------------------------------------------------------------------===// -// Extra Type Info +// Extension Type Info //===--------------------------------------------------------------------===// -ExtraTypeInfo::ExtraTypeInfo(ExtraTypeInfoType type) : type(type) { -} -ExtraTypeInfo::ExtraTypeInfo(ExtraTypeInfoType type, string alias) : type(type), alias(std::move(alias)) { -} -ExtraTypeInfo::~ExtraTypeInfo() { -} -shared_ptr ExtraTypeInfo::Copy() const { - return make_shared_ptr(*this); -} static bool CompareModifiers(const vector &left, const vector &right) { // Check if the common prefix of the properties is the same for both types - auto common_props = MinValue(left.size(), right.size()); + const auto common_props = MinValue(left.size(), right.size()); for (idx_t i = 0; i < common_props; i++) { if (left[i].type() != right[i].type()) { return false; @@ -34,6 +25,7 @@ static bool CompareModifiers(const vector &left, const vector &rig if (left[i].IsNull() || right[i].IsNull()) { continue; } + if (left[i] != right[i]) { return false; } @@ -41,6 +33,57 @@ static bool CompareModifiers(const vector &left, const vector &rig return true; } +bool ExtensionTypeInfo::Equals(optional_ptr other_p) const { + if (other_p == nullptr) { + return false; + } + if (!CompareModifiers(modifiers, other_p->modifiers)) { + return false; + } + + // Properties are optional, so only compare those present in both + for (auto &kv : properties) { + auto it = other_p->properties.find(kv.first); + if (it == other_p->properties.end()) { + continue; + } + if (kv.second != it->second) { + return false; + } + } + + return true; +} + +//===--------------------------------------------------------------------===// +// Extra Type Info +//===--------------------------------------------------------------------===// +ExtraTypeInfo::ExtraTypeInfo(ExtraTypeInfoType type) : type(type) { +} +ExtraTypeInfo::ExtraTypeInfo(ExtraTypeInfoType type, string alias) : type(type), alias(std::move(alias)) { +} +ExtraTypeInfo::~ExtraTypeInfo() { +} + +ExtraTypeInfo::ExtraTypeInfo(const ExtraTypeInfo &other) : type(other.type), alias(other.alias) { + if (other.extension_info) { + extension_info = make_uniq(*other.extension_info); + } +} + +ExtraTypeInfo &ExtraTypeInfo::operator=(const ExtraTypeInfo &other) { + type = other.type; + alias = other.alias; + if (other.extension_info) { + extension_info = make_uniq(*other.extension_info); + } + return *this; +} + +shared_ptr ExtraTypeInfo::Copy() const { + return shared_ptr(new ExtraTypeInfo(*this)); +} + bool ExtraTypeInfo::Equals(ExtraTypeInfo *other_p) const { if (type == ExtraTypeInfoType::INVALID_TYPE_INFO || type == ExtraTypeInfoType::STRING_TYPE_INFO || type == ExtraTypeInfoType::GENERIC_TYPE_INFO) { @@ -54,7 +97,7 @@ bool ExtraTypeInfo::Equals(ExtraTypeInfo *other_p) const { if (alias != other_p->alias) { return false; } - if (!CompareModifiers(modifiers, other_p->modifiers)) { + if (extension_info && !extension_info->Equals(other_p->extension_info.get())) { return false; } return true; @@ -68,7 +111,7 @@ bool ExtraTypeInfo::Equals(ExtraTypeInfo *other_p) const { if (alias != other_p->alias) { return false; } - if (!CompareModifiers(modifiers, other_p->modifiers)) { + if (extension_info && !extension_info->Equals(other_p->extension_info.get())) { return false; } return EqualsInternal(other_p); diff --git a/src/duckdb/src/common/progress_bar/progress_bar.cpp b/src/duckdb/src/common/progress_bar/progress_bar.cpp index 2fa8c0adf..4a3de66fb 100644 --- a/src/duckdb/src/common/progress_bar/progress_bar.cpp +++ b/src/duckdb/src/common/progress_bar/progress_bar.cpp @@ -130,13 +130,11 @@ void ProgressBar::Update(bool final) { query_progress.percentage = new_percentage; } if (ShouldPrint(final)) { -#ifndef DUCKDB_DISABLE_PRINT if (final) { FinishProgressBarPrint(); } else { PrintProgress(LossyNumericCast(query_progress.percentage.load())); } -#endif } } diff --git a/src/duckdb/src/common/types.cpp b/src/duckdb/src/common/types.cpp index 6c3a79130..52002ded4 100644 --- a/src/duckdb/src/common/types.cpp +++ b/src/duckdb/src/common/types.cpp @@ -365,21 +365,29 @@ bool TypeIsInteger(PhysicalType type) { type == PhysicalType::UINT128; } +static string TypeModifierListToString(const vector &mod_list) { + string result; + if (mod_list.empty()) { + return result; + } + result = "("; + for (idx_t i = 0; i < mod_list.size(); i++) { + result += mod_list[i].ToString(); + if (i < mod_list.size() - 1) { + result += ", "; + } + } + result += ")"; + return result; +} + string LogicalType::ToString() const { if (id_ != LogicalTypeId::USER) { auto alias = GetAlias(); if (!alias.empty()) { - auto mods_ptr = GetModifiers(); - if (mods_ptr && !mods_ptr->empty()) { - auto &mods = *mods_ptr; - alias += "("; - for (idx_t i = 0; i < mods.size(); i++) { - alias += mods[i].ToString(); - if (i < mods.size() - 1) { - alias += ", "; - } - } - alias += ")"; + if (HasExtensionInfo()) { + auto &ext_info = *GetExtensionInfo(); + alias += TypeModifierListToString(ext_info.modifiers); } return alias; } @@ -491,14 +499,7 @@ string LogicalType::ToString() const { 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 += ")"; + result += TypeModifierListToString(mods); } return result; @@ -1360,51 +1361,32 @@ bool LogicalType::HasAlias() const { return false; } -void LogicalType::SetModifiers(vector modifiers) { - if (!type_info_ && !modifiers.empty()) { - type_info_ = make_shared_ptr(ExtraTypeInfoType::GENERIC_TYPE_INFO); - } - type_info_->modifiers = std::move(modifiers); -} - -bool LogicalType::HasModifiers() const { - if (id() == LogicalTypeId::USER) { - return !UserType::GetTypeModifiers(*this).empty(); - } - if (type_info_) { - return !type_info_->modifiers.empty(); +bool LogicalType::HasExtensionInfo() const { + if (type_info_ && type_info_->extension_info) { + return true; } return false; } -vector LogicalType::GetModifiersCopy() const { - if (id() == LogicalTypeId::USER) { - return UserType::GetTypeModifiers(*this); - } - if (type_info_) { - return type_info_->modifiers; +optional_ptr LogicalType::GetExtensionInfo() const { + if (type_info_ && type_info_->extension_info) { + return type_info_->extension_info.get(); } - return {}; + return nullptr; } -optional_ptr> LogicalType::GetModifiers() { - if (id() == LogicalTypeId::USER) { - return UserType::GetTypeModifiers(*this); - } - if (type_info_) { - return type_info_->modifiers; +optional_ptr LogicalType::GetExtensionInfo() { + if (type_info_ && type_info_->extension_info) { + return type_info_->extension_info.get(); } return nullptr; } -optional_ptr> LogicalType::GetModifiers() const { - if (id() == LogicalTypeId::USER) { - return UserType::GetTypeModifiers(*this); - } - if (type_info_) { - return type_info_->modifiers; +void LogicalType::SetExtensionInfo(unique_ptr info) { + if (!type_info_) { + type_info_ = make_shared_ptr(ExtraTypeInfoType::GENERIC_TYPE_INFO); } - return nullptr; + type_info_->extension_info = std::move(info); } //===--------------------------------------------------------------------===// diff --git a/src/duckdb/src/execution/operator/persistent/physical_copy_database.cpp b/src/duckdb/src/execution/operator/persistent/physical_copy_database.cpp index 353c091c8..6ad354ea2 100644 --- a/src/duckdb/src/execution/operator/persistent/physical_copy_database.cpp +++ b/src/duckdb/src/execution/operator/persistent/physical_copy_database.cpp @@ -42,6 +42,7 @@ SourceResultType PhysicalCopyDatabase::GetData(ExecutionContext &context, DataCh catalog.CreateType(context.client, create_info->Cast()); break; case CatalogType::MACRO_ENTRY: + case CatalogType::TABLE_MACRO_ENTRY: catalog.CreateFunction(context.client, create_info->Cast()); break; case CatalogType::TABLE_ENTRY: { diff --git a/src/duckdb/src/execution/physical_plan/plan_get.cpp b/src/duckdb/src/execution/physical_plan/plan_get.cpp index 4aba3a443..3b5d940eb 100644 --- a/src/duckdb/src/execution/physical_plan/plan_get.cpp +++ b/src/duckdb/src/execution/physical_plan/plan_get.cpp @@ -160,8 +160,9 @@ unique_ptr PhysicalPlanGenerator::CreatePlan(LogicalGet &op) { vector> expressions; for (auto &column_id : column_ids) { if (column_id.IsRowIdColumn()) { - types.emplace_back(LogicalType::ROW_TYPE); - expressions.push_back(make_uniq(Value::BIGINT(0))); + types.emplace_back(op.GetRowIdType()); + // Now how to make that a constant expression. + expressions.push_back(make_uniq(Value(op.GetRowIdType()))); } else { auto col_id = column_id.GetPrimaryIndex(); auto type = op.returned_types[col_id]; diff --git a/src/duckdb/src/function/table/arrow_conversion.cpp b/src/duckdb/src/function/table/arrow_conversion.cpp index 261635e1c..18daff2b9 100644 --- a/src/duckdb/src/function/table/arrow_conversion.cpp +++ b/src/duckdb/src/function/table/arrow_conversion.cpp @@ -1340,7 +1340,8 @@ static void ColumnArrowToDuckDBDictionary(Vector &vector, ArrowArray &array, Arr } void ArrowTableFunction::ArrowToDuckDB(ArrowScanLocalState &scan_state, const arrow_column_map_t &arrow_convert_data, - DataChunk &output, idx_t start, bool arrow_scan_is_projected) { + DataChunk &output, idx_t start, bool arrow_scan_is_projected, + idx_t rowid_column_index) { for (idx_t idx = 0; idx < output.ColumnCount(); idx++) { auto col_idx = scan_state.column_ids.empty() ? idx : scan_state.column_ids[idx]; @@ -1348,9 +1349,22 @@ void ArrowTableFunction::ArrowToDuckDB(ArrowScanLocalState &scan_state, const ar // table function, we need to use original column ids here. auto arrow_array_idx = arrow_scan_is_projected ? idx : col_idx; - if (col_idx == COLUMN_IDENTIFIER_ROW_ID) { - // This column is skipped by the projection pushdown - continue; + if (rowid_column_index != COLUMN_IDENTIFIER_ROW_ID) { + if (col_idx == COLUMN_IDENTIFIER_ROW_ID) { + arrow_array_idx = rowid_column_index; + } else if (col_idx >= rowid_column_index) { + // Since the rowid column is skipped when the table is bound (its not a named column), + // we need to shift references forward in the Arrow array by one to match the alignment + // that DuckDB believes the Arrow array is in. + col_idx += 1; + arrow_array_idx += 1; + } + } else { + // If there isn't any defined row_id_index, and we're asked for it, skip the column. + // This is the incumbent behavior. + if (col_idx == COLUMN_IDENTIFIER_ROW_ID) { + continue; + } } auto &parent_array = scan_state.chunk->arrow_array; diff --git a/src/duckdb/src/function/table/version/pragma_version.cpp b/src/duckdb/src/function/table/version/pragma_version.cpp index c68f78fca..167f071af 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 "4-dev3961" +#define DUCKDB_PATCH_VERSION "4-dev3985" #endif #ifndef DUCKDB_MINOR_VERSION #define DUCKDB_MINOR_VERSION 1 @@ -8,10 +8,10 @@ #define DUCKDB_MAJOR_VERSION 1 #endif #ifndef DUCKDB_VERSION -#define DUCKDB_VERSION "v1.1.4-dev3961" +#define DUCKDB_VERSION "v1.1.4-dev3985" #endif #ifndef DUCKDB_SOURCE_ID -#define DUCKDB_SOURCE_ID "4488c61ee7" +#define DUCKDB_SOURCE_ID "adc6f607a7" #endif #include "duckdb/function/table/system_functions.hpp" #include "duckdb/main/database.hpp" diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_catalog_entry.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_catalog_entry.hpp index 5ce45af7f..398e49974 100644 --- a/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_catalog_entry.hpp +++ b/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_catalog_entry.hpp @@ -117,6 +117,11 @@ class TableCatalogEntry : public StandardEntry { //! Returns true, if the table has a primary key, else false. bool HasPrimaryKey() const; + //! Returns the rowid type of this table + virtual LogicalType GetRowIdType() const { + return LogicalType::ROW_TYPE; + } + protected: //! A list of columns that are part of this table ColumnList columns; diff --git a/src/duckdb/src/include/duckdb/common/extension_type_info.hpp b/src/duckdb/src/include/duckdb/common/extension_type_info.hpp new file mode 100644 index 000000000..48e12d3c3 --- /dev/null +++ b/src/duckdb/src/include/duckdb/common/extension_type_info.hpp @@ -0,0 +1,19 @@ +#pragma once + +#include "duckdb/common/string.hpp" +#include "duckdb/common/types/value.hpp" +#include "duckdb/common/serializer/serializer.hpp" + +namespace duckdb { + +struct ExtensionTypeInfo { + vector modifiers; + unordered_map properties; + +public: + void Serialize(Serializer &serializer) const; + static unique_ptr Deserialize(Deserializer &source); + bool Equals(optional_ptr other_p) const; +}; + +} // 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 7ed7197b5..8e9afe0d2 100644 --- a/src/duckdb/src/include/duckdb/common/extra_type_info.hpp +++ b/src/duckdb/src/include/duckdb/common/extra_type_info.hpp @@ -10,6 +10,7 @@ #include "duckdb/common/common.hpp" #include "duckdb/common/types/vector.hpp" +#include "duckdb/common/extension_type_info.hpp" namespace duckdb { @@ -30,13 +31,18 @@ enum class ExtraTypeInfoType : uint8_t { }; struct ExtraTypeInfo { + ExtraTypeInfoType type; + string alias; + unique_ptr extension_info; + explicit ExtraTypeInfo(ExtraTypeInfoType type); explicit ExtraTypeInfo(ExtraTypeInfoType type, string alias); virtual ~ExtraTypeInfo(); - ExtraTypeInfoType type; - string alias; - vector modifiers; +protected: + // copy constructor (protected) + ExtraTypeInfo(const ExtraTypeInfo &other); + ExtraTypeInfo &operator=(const ExtraTypeInfo &other); public: bool Equals(ExtraTypeInfo *other_p) const; diff --git a/src/duckdb/src/include/duckdb/common/types.hpp b/src/duckdb/src/include/duckdb/common/types.hpp index 216e1a361..1bc43811a 100644 --- a/src/duckdb/src/include/duckdb/common/types.hpp +++ b/src/duckdb/src/include/duckdb/common/types.hpp @@ -234,6 +234,7 @@ enum class LogicalTypeId : uint8_t { }; struct ExtraTypeInfo; +struct ExtensionTypeInfo; struct aggregate_state_t; // NOLINT: mimic std casing @@ -323,11 +324,11 @@ struct LogicalType { DUCKDB_API void SetAlias(string alias); DUCKDB_API bool HasAlias() const; DUCKDB_API string GetAlias() const; - DUCKDB_API void SetModifiers(vector modifiers); - DUCKDB_API bool HasModifiers() const; - DUCKDB_API vector GetModifiersCopy() const; - DUCKDB_API optional_ptr> GetModifiers(); - DUCKDB_API optional_ptr> GetModifiers() const; + + DUCKDB_API bool HasExtensionInfo() const; + DUCKDB_API optional_ptr GetExtensionInfo() const; + DUCKDB_API optional_ptr GetExtensionInfo(); + DUCKDB_API void SetExtensionInfo(unique_ptr info); //! 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); diff --git a/src/duckdb/src/include/duckdb/function/table/arrow.hpp b/src/duckdb/src/include/duckdb/function/table/arrow.hpp index 4f8f24f3d..7db6cd363 100644 --- a/src/duckdb/src/include/duckdb/function/table/arrow.hpp +++ b/src/duckdb/src/include/duckdb/function/table/arrow.hpp @@ -190,7 +190,8 @@ struct ArrowTableFunction { vector &return_types, vector &names); //! Actual conversion from Arrow to DuckDB static void ArrowToDuckDB(ArrowScanLocalState &scan_state, const arrow_column_map_t &arrow_convert_data, - DataChunk &output, idx_t start, bool arrow_scan_is_projected = true); + DataChunk &output, idx_t start, bool arrow_scan_is_projected = true, + idx_t rowid_column_index = COLUMN_IDENTIFIER_ROW_ID); //! Get next scan state static bool ArrowScanParallelStateNext(ClientContext &context, const FunctionData *bind_data_p, diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_get.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_get.hpp index 993863c11..0a73d12cb 100644 --- a/src/duckdb/src/include/duckdb/planner/operator/logical_get.hpp +++ b/src/duckdb/src/include/duckdb/planner/operator/logical_get.hpp @@ -23,7 +23,8 @@ class LogicalGet : public LogicalOperator { public: LogicalGet(idx_t table_index, TableFunction function, unique_ptr bind_data, - vector returned_types, vector returned_names); + vector returned_types, vector returned_names, + LogicalType rowid_type = LogicalType(LogicalType::ROW_TYPE)); //! The table index in the current bind context idx_t table_index; @@ -79,6 +80,10 @@ class LogicalGet : public LogicalOperator { void Serialize(Serializer &serializer) const override; static unique_ptr Deserialize(Deserializer &deserializer); + LogicalType GetRowIdType() const { + return rowid_type; + } + protected: void ResolveTypes() override; @@ -88,5 +93,8 @@ class LogicalGet : public LogicalOperator { private: //! Bound column IDs vector column_ids; + + //! The type of the rowid column + LogicalType rowid_type = LogicalType(LogicalType::ROW_TYPE); }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/planner/table_binding.hpp b/src/duckdb/src/include/duckdb/planner/table_binding.hpp index 4b9030b47..50631f57a 100644 --- a/src/duckdb/src/include/duckdb/planner/table_binding.hpp +++ b/src/duckdb/src/include/duckdb/planner/table_binding.hpp @@ -33,7 +33,8 @@ enum class BindingType { BASE, TABLE, DUMMY, CATALOG_ENTRY }; //! A Binding represents a binding to a table, table-producing function or subquery with a specified table index. struct Binding { - Binding(BindingType binding_type, BindingAlias alias, vector types, vector names, idx_t index); + Binding(BindingType binding_type, BindingAlias alias, vector types, vector names, idx_t index, + LogicalType rowid_type = LogicalType(LogicalType::ROW_TYPE)); virtual ~Binding() = default; //! The type of Binding @@ -49,6 +50,8 @@ struct Binding { //! Name -> index for the names case_insensitive_map_t name_map; + LogicalType rowid_type; + public: bool TryGetBindingIndex(const string &column_name, column_t &column_index); column_t GetBindingIndex(const string &column_name); diff --git a/src/duckdb/src/main/config.cpp b/src/duckdb/src/main/config.cpp index 5788d296e..2c604cec3 100644 --- a/src/duckdb/src/main/config.cpp +++ b/src/duckdb/src/main/config.cpp @@ -548,8 +548,9 @@ idx_t DBConfig::ParseMemoryLimit(const string &arg) { } else if (unit == "tib") { multiplier = 1024LL * 1024LL * 1024LL * 1024LL; } else { - throw ParserException("Unknown unit for memory_limit: %s (expected: KB, MB, GB, TB for 1000^i units or KiB, " - "MiB, GiB, TiB for 1024^i unites)"); + throw ParserException("Unknown unit for memory_limit: '%s' (expected: KB, MB, GB, TB for 1000^i units or KiB, " + "MiB, GiB, TiB for 1024^i units)", + unit); } return LossyNumericCast(static_cast(multiplier) * limit); } diff --git a/src/duckdb/src/main/settings/custom_settings.cpp b/src/duckdb/src/main/settings/custom_settings.cpp index e8de192ab..57e961a22 100644 --- a/src/duckdb/src/main/settings/custom_settings.cpp +++ b/src/duckdb/src/main/settings/custom_settings.cpp @@ -895,6 +895,10 @@ Value MaxMemorySetting::GetSetting(const ClientContext &context) { // Max Temp Directory Size //===----------------------------------------------------------------------===// void MaxTempDirectorySizeSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { + if (input == "90% of available disk space") { + ResetGlobal(db, config); + return; + } auto maximum_swap_space = DBConfig::ParseMemoryLimit(input.ToString()); if (maximum_swap_space == DConstants::INVALID_INDEX) { // We use INVALID_INDEX to indicate that the value is not set by the user diff --git a/src/duckdb/src/parser/transform/helpers/transform_typename.cpp b/src/duckdb/src/parser/transform/helpers/transform_typename.cpp index bd6b97a10..a7beb3ba2 100644 --- a/src/duckdb/src/parser/transform/helpers/transform_typename.cpp +++ b/src/duckdb/src/parser/transform/helpers/transform_typename.cpp @@ -57,14 +57,15 @@ vector Transformer::TransformTypeModifiers(duckdb_libpgquery::PGTypeName if (type_name.typmods) { for (auto node = type_name.typmods->head; node; node = node->next) { if (type_mods.size() > 9) { - auto name = PGPointerCast(type_name.names->tail->data.ptr_value)->val.str; + 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); } - auto &const_val = *PGPointerCast(node->data.ptr_value); + 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"); } - auto const_expr = TransformValue(const_val.val); + const auto const_expr = TransformValue(const_val.val); type_mods.push_back(std::move(const_expr->value)); } } diff --git a/src/duckdb/src/planner/binder/statement/bind_create.cpp b/src/duckdb/src/planner/binder/statement/bind_create.cpp index 156be1e5d..495a687e6 100644 --- a/src/duckdb/src/planner/binder/statement/bind_create.cpp +++ b/src/duckdb/src/planner/binder/statement/bind_create.cpp @@ -40,6 +40,7 @@ #include "duckdb/planner/query_node/bound_select_node.hpp" #include "duckdb/planner/tableref/bound_basetableref.hpp" #include "duckdb/storage/storage_extension.hpp" +#include "duckdb/common/extension_type_info.hpp" namespace duckdb { @@ -253,139 +254,145 @@ static bool IsValidUserType(optional_ptr entry) { } void Binder::BindLogicalType(LogicalType &type, optional_ptr catalog, const string &schema) { - if (type.id() == LogicalTypeId::LIST || type.id() == LogicalTypeId::MAP) { - auto child_type = ListType::GetChildType(type); - BindLogicalType(child_type, catalog, schema); + if (type.id() != LogicalTypeId::USER) { + // Recursive types, make sure to bind any nested user types recursively auto alias = type.GetAlias(); - auto modifiers = type.GetModifiersCopy(); - if (type.id() == LogicalTypeId::LIST) { + auto ext_info = type.HasExtensionInfo() ? make_uniq(*type.GetExtensionInfo()) : nullptr; + + switch (type.id()) { + case LogicalTypeId::LIST: { + auto child_type = ListType::GetChildType(type); + BindLogicalType(child_type, catalog, schema); type = LogicalType::LIST(child_type); - } else { - D_ASSERT(child_type.id() == LogicalTypeId::STRUCT); // map must be list of structs - type = LogicalType::MAP(child_type); + } break; + case LogicalTypeId::MAP: { + auto key_type = MapType::KeyType(type); + BindLogicalType(key_type, catalog, schema); + auto value_type = MapType::ValueType(type); + BindLogicalType(value_type, catalog, schema); + type = LogicalType::MAP(key_type, value_type); + } break; + case LogicalTypeId::ARRAY: { + auto child_type = ArrayType::GetChildType(type); + auto array_size = ArrayType::GetSize(type); + BindLogicalType(child_type, catalog, schema); + type = LogicalType::ARRAY(child_type, array_size); + } break; + case LogicalTypeId::STRUCT: { + auto child_types = StructType::GetChildTypes(type); + for (auto &child_type : child_types) { + BindLogicalType(child_type.second, catalog, schema); + } + type = LogicalType::STRUCT(child_types); + } break; + case LogicalTypeId::UNION: { + auto member_types = UnionType::CopyMemberTypes(type); + for (auto &member_type : member_types) { + BindLogicalType(member_type.second, catalog, schema); + } + type = LogicalType::UNION(member_types); + } break; + default: + break; } + // Set the alias and extension info back type.SetAlias(alias); - type.SetModifiers(modifiers); - } else if (type.id() == LogicalTypeId::STRUCT) { - auto child_types = StructType::GetChildTypes(type); - for (auto &child_type : child_types) { - BindLogicalType(child_type.second, catalog, schema); + type.SetExtensionInfo(std::move(ext_info)); + + return; + } + + // 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_type_modifiers_function_t user_bind_modifiers_func = nullptr; + + 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(CatalogType::TYPE_ENTRY, *catalog, user_type_schema, user_type_name, + OnEntryNotFound::RETURN_NULL); } - // Generate new Struct Type - auto alias = type.GetAlias(); - auto modifiers = type.GetModifiersCopy(); - type = LogicalType::STRUCT(child_types); - type.SetAlias(alias); - type.SetModifiers(modifiers); - } else if (type.id() == LogicalTypeId::ARRAY) { - auto child_type = ArrayType::GetChildType(type); - auto array_size = ArrayType::GetSize(type); - BindLogicalType(child_type, catalog, schema); - auto alias = type.GetAlias(); - auto modifiers = type.GetModifiersCopy(); - type = LogicalType::ARRAY(child_type, array_size); - type.SetAlias(alias); - type.SetModifiers(modifiers); - } else if (type.id() == LogicalTypeId::UNION) { - auto member_types = UnionType::CopyMemberTypes(type); - for (auto &member_type : member_types) { - BindLogicalType(member_type.second, catalog, schema); + if (!IsValidUserType(entry)) { + entry = entry_retriever.GetEntry(CatalogType::TYPE_ENTRY, *catalog, schema, user_type_name, + OnEntryNotFound::RETURN_NULL); } - // Generate new Union Type - auto alias = type.GetAlias(); - auto modifiers = type.GetModifiersCopy(); - type = LogicalType::UNION(member_types); - type.SetAlias(alias); - type.SetModifiers(modifiers); - } else if (type.id() == LogicalTypeId::USER) { - auto user_type_name = UserType::GetTypeName(type); - auto user_type_schema = UserType::GetSchema(type); - auto user_type_mods = UserType::GetTypeModifiers(type); - - bind_type_modifiers_function_t user_bind_modifiers_func = nullptr; - - 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(CatalogType::TYPE_ENTRY, *catalog, user_type_schema, user_type_name, - OnEntryNotFound::RETURN_NULL); - } - if (!IsValidUserType(entry)) { - entry = entry_retriever.GetEntry(CatalogType::TYPE_ENTRY, *catalog, schema, user_type_name, - OnEntryNotFound::RETURN_NULL); - } - if (!IsValidUserType(entry)) { - entry = entry_retriever.GetEntry(CatalogType::TYPE_ENTRY, *catalog, INVALID_SCHEMA, user_type_name, - OnEntryNotFound::RETURN_NULL); - } - if (!IsValidUserType(entry)) { - entry = entry_retriever.GetEntry(CatalogType::TYPE_ENTRY, INVALID_CATALOG, INVALID_SCHEMA, - user_type_name, OnEntryNotFound::THROW_EXCEPTION); - } - auto &type_entry = entry->Cast(); - type = type_entry.user_type; - user_bind_modifiers_func = type_entry.bind_modifiers; - } else { - string type_catalog = UserType::GetCatalog(type); - string type_schema = UserType::GetSchema(type); - - BindSchemaOrCatalog(context, type_catalog, type_schema); - auto entry = entry_retriever.GetEntry(CatalogType::TYPE_ENTRY, type_catalog, type_schema, user_type_name); - auto &type_entry = entry->Cast(); - type = type_entry.user_type; - user_bind_modifiers_func = type_entry.bind_modifiers; + if (!IsValidUserType(entry)) { + entry = entry_retriever.GetEntry(CatalogType::TYPE_ENTRY, *catalog, INVALID_SCHEMA, user_type_name, + OnEntryNotFound::RETURN_NULL); + } + if (!IsValidUserType(entry)) { + entry = entry_retriever.GetEntry(CatalogType::TYPE_ENTRY, INVALID_CATALOG, INVALID_SCHEMA, user_type_name, + OnEntryNotFound::THROW_EXCEPTION); } + auto &type_entry = entry->Cast(); + type = type_entry.user_type; + user_bind_modifiers_func = type_entry.bind_modifiers; + } else { + string type_catalog = UserType::GetCatalog(type); + string type_schema = UserType::GetSchema(type); + + BindSchemaOrCatalog(context, type_catalog, type_schema); + auto entry = entry_retriever.GetEntry(CatalogType::TYPE_ENTRY, type_catalog, type_schema, user_type_name); + auto &type_entry = entry->Cast(); + type = type_entry.user_type; + user_bind_modifiers_func = type_entry.bind_modifiers; + } - BindLogicalType(type, catalog, schema); - - // Apply the type modifiers (if any) - if (user_bind_modifiers_func) { - // If an explicit bind_modifiers function was provided, use that to set the type modifier - BindTypeModifiersInput input {context, type, user_type_mods}; - type = user_bind_modifiers_func(input); - } else if (type.HasModifiers()) { - // If the type already has modifiers, try to replace them with the user-provided ones if they are compatible - // This enables registering custom types with "default" type modifiers that can be overridden, without - // having to provide a custom bind_modifiers function - auto type_mods_size = type.GetModifiers()->size(); - - // Are we trying to pass more type modifiers than the type has? - if (user_type_mods.size() > type_mods_size) { - throw BinderException( - "Cannot apply '%d' type modifier(s) to type '%s' taking at most '%d' type modifier(s)", - user_type_mods.size(), user_type_name, type_mods_size); - } + // Now we bind the inner user type + BindLogicalType(type, catalog, schema); - // Deep copy the type so that we can replace the type modifiers - type = type.DeepCopy(); - - // Re-fetch the type modifiers now that we've deduplicated the ExtraTypeInfo - auto &type_mods = *type.GetModifiers(); - - // Replace them in order, casting if necessary - for (idx_t i = 0; i < MinValue(type_mods.size(), user_type_mods.size()); i++) { - auto &type_mod = type_mods[i]; - auto user_type_mod = user_type_mods[i]; - if (type_mod.type() == user_type_mod.type()) { - type_mod = std::move(user_type_mod); - } else if (user_type_mod.DefaultTryCastAs(type_mod.type())) { - type_mod = std::move(user_type_mod); - } else { - throw BinderException("Cannot apply type modifier '%s' to type '%s', expected value of type '%s'", - user_type_mod.ToString(), user_type_name, type_mod.type().ToString()); - } + // 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 + BindTypeModifiersInput input {context, type, user_type_mods}; + type = user_bind_modifiers_func(input); + } else if (type.HasExtensionInfo()) { + auto &ext_info = *type.GetExtensionInfo(); + + // If the type already has modifiers, try to replace them with the user-provided ones if they are compatible + // This enables registering custom types with "default" type modifiers that can be overridden, without + // having to provide a custom bind_modifiers function + auto type_mods_size = ext_info.modifiers.size(); + + // Are we trying to pass more type modifiers than the type has? + if (user_type_mods.size() > type_mods_size) { + throw BinderException( + "Cannot apply '%d' type modifier(s) to type '%s' taking at most '%d' type modifier(s)", + user_type_mods.size(), user_type_name, type_mods_size); + } + + // Deep copy the type so that we can replace the type modifiers + type = type.DeepCopy(); + + // Re-fetch the type modifiers now that we've deduplicated the ExtraTypeInfo + auto &type_mods = type.GetExtensionInfo()->modifiers; + + // Replace them in order, casting if necessary + for (idx_t i = 0; i < MinValue(type_mods.size(), user_type_mods.size()); i++) { + auto &type_mod = type_mods[i]; + auto user_type_mod = user_type_mods[i]; + if (type_mod.type() == user_type_mod.type()) { + type_mod = std::move(user_type_mod); + } else if (user_type_mod.DefaultTryCastAs(type_mod.type())) { + type_mod = std::move(user_type_mod); + } else { + throw BinderException("Cannot apply type modifier '%s' to type '%s', expected value of type '%s'", + user_type_mod.ToString(), user_type_name, type_mod.type().ToString()); } - } else if (!user_type_mods.empty()) { - // We're trying to pass type modifiers to a type that doesnt have any - throw BinderException("Type '%s' does not take any type modifiers", user_type_name); } + } else if (!user_type_mods.empty()) { + // We're trying to pass type modifiers to a type that doesnt have any + throw BinderException("Type '%s' does not take any type modifiers", user_type_name); } } diff --git a/src/duckdb/src/planner/binder/statement/bind_delete.cpp b/src/duckdb/src/planner/binder/statement/bind_delete.cpp index cb9457d70..822f487ed 100644 --- a/src/duckdb/src/planner/binder/statement/bind_delete.cpp +++ b/src/duckdb/src/planner/binder/statement/bind_delete.cpp @@ -76,7 +76,7 @@ BoundStatement Binder::Bind(DeleteStatement &stmt) { // set up the delete expression auto &column_ids = get.GetColumnIds(); del->expressions.push_back( - make_uniq(LogicalType::ROW_TYPE, ColumnBinding(get.table_index, column_ids.size()))); + make_uniq(table.GetRowIdType(), ColumnBinding(get.table_index, column_ids.size()))); get.AddColumnId(COLUMN_IDENTIFIER_ROW_ID); if (!stmt.returning_list.empty()) { diff --git a/src/duckdb/src/planner/binder/statement/bind_update.cpp b/src/duckdb/src/planner/binder/statement/bind_update.cpp index ba25497ed..75dd39074 100644 --- a/src/duckdb/src/planner/binder/statement/bind_update.cpp +++ b/src/duckdb/src/planner/binder/statement/bind_update.cpp @@ -135,7 +135,7 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) { // finally add the row id column to the projection list auto &column_ids = get->GetColumnIds(); proj->expressions.push_back( - make_uniq(LogicalType::ROW_TYPE, ColumnBinding(get->table_index, column_ids.size()))); + make_uniq(table.GetRowIdType(), ColumnBinding(get->table_index, column_ids.size()))); get->AddColumnId(COLUMN_IDENTIFIER_ROW_ID); // set the projection as child of the update node and finalize the result diff --git a/src/duckdb/src/planner/binder/tableref/bind_basetableref.cpp b/src/duckdb/src/planner/binder/tableref/bind_basetableref.cpp index ba41b051e..f2566cf71 100644 --- a/src/duckdb/src/planner/binder/tableref/bind_basetableref.cpp +++ b/src/duckdb/src/planner/binder/tableref/bind_basetableref.cpp @@ -247,8 +247,9 @@ unique_ptr Binder::Bind(BaseTableRef &ref) { } table_names = BindContext::AliasColumnNames(ref.table_name, table_names, ref.column_name_alias); - auto logical_get = make_uniq(table_index, scan_function, std::move(bind_data), - std::move(return_types), std::move(return_names)); + auto logical_get = + make_uniq(table_index, scan_function, std::move(bind_data), std::move(return_types), + std::move(return_names), table.GetRowIdType()); auto table_entry = logical_get->GetTable(); auto &col_ids = logical_get->GetMutableColumnIds(); if (!table_entry) { diff --git a/src/duckdb/src/planner/expression/bound_window_expression.cpp b/src/duckdb/src/planner/expression/bound_window_expression.cpp index 2701bd57a..5f778db14 100644 --- a/src/duckdb/src/planner/expression/bound_window_expression.cpp +++ b/src/duckdb/src/planner/expression/bound_window_expression.cpp @@ -233,7 +233,7 @@ unique_ptr BoundWindowExpression::Deserialize(Deserializer &deserial deserializer.ReadPropertyWithExplicitDefault(211, "default_expr", result->default_expr, unique_ptr()); deserializer.ReadProperty(212, "exclude_clause", result->exclude_clause); deserializer.ReadProperty(213, "distinct", result->distinct); - deserializer.ReadProperty(214, "arg_orders", result->arg_orders); + deserializer.ReadPropertyWithExplicitDefault(214, "arg_orders", result->arg_orders, vector()); return std::move(result); } diff --git a/src/duckdb/src/planner/operator/logical_get.cpp b/src/duckdb/src/planner/operator/logical_get.cpp index 97dbe3f69..be7b5aa5d 100644 --- a/src/duckdb/src/planner/operator/logical_get.cpp +++ b/src/duckdb/src/planner/operator/logical_get.cpp @@ -17,10 +17,10 @@ LogicalGet::LogicalGet() : LogicalOperator(LogicalOperatorType::LOGICAL_GET) { } LogicalGet::LogicalGet(idx_t table_index, TableFunction function, unique_ptr bind_data, - vector returned_types, vector returned_names) + vector returned_types, vector returned_names, LogicalType rowid_type) : LogicalOperator(LogicalOperatorType::LOGICAL_GET), table_index(table_index), function(std::move(function)), bind_data(std::move(bind_data)), returned_types(std::move(returned_types)), names(std::move(returned_names)), - extra_info() { + extra_info(), rowid_type(std::move(rowid_type)) { } optional_ptr LogicalGet::GetTable() const { @@ -126,7 +126,7 @@ void LogicalGet::ResolveTypes() { if (projection_ids.empty()) { for (auto &index : column_ids) { if (index.IsRowIdColumn()) { - types.emplace_back(LogicalType::ROW_TYPE); + types.emplace_back(LogicalType(rowid_type)); } else { types.push_back(returned_types[index.GetPrimaryIndex()]); } @@ -135,7 +135,7 @@ void LogicalGet::ResolveTypes() { for (auto &proj_index : projection_ids) { auto &index = column_ids[proj_index]; if (index.IsRowIdColumn()) { - types.emplace_back(LogicalType::ROW_TYPE); + types.emplace_back(LogicalType(rowid_type)); } else { types.push_back(returned_types[index.GetPrimaryIndex()]); } diff --git a/src/duckdb/src/planner/table_binding.cpp b/src/duckdb/src/planner/table_binding.cpp index 119db130d..455834a4b 100644 --- a/src/duckdb/src/planner/table_binding.cpp +++ b/src/duckdb/src/planner/table_binding.cpp @@ -16,9 +16,9 @@ namespace duckdb { Binding::Binding(BindingType binding_type, BindingAlias alias_p, vector coltypes, vector colnames, - idx_t index) + idx_t index, LogicalType rowid_type) : binding_type(binding_type), alias(std::move(alias_p)), index(index), types(std::move(coltypes)), - names(std::move(colnames)) { + names(std::move(colnames)), rowid_type(std::move(rowid_type)) { D_ASSERT(types.size() == names.size()); for (idx_t i = 0; i < names.size(); i++) { auto &name = names[i]; @@ -115,7 +115,8 @@ optional_ptr EntryBinding::GetStandardEntry() { TableBinding::TableBinding(const string &alias, vector types_p, vector names_p, vector &bound_column_ids, optional_ptr entry, idx_t index, bool add_row_id) - : Binding(BindingType::TABLE, GetAlias(alias, entry), std::move(types_p), std::move(names_p), index), + : Binding(BindingType::TABLE, GetAlias(alias, entry), std::move(types_p), std::move(names_p), index, + (add_row_id && entry) ? entry->Cast().GetRowIdType() : LogicalType::ROW_TYPE), bound_column_ids(bound_column_ids), entry(entry) { if (add_row_id) { if (name_map.find("rowid") == name_map.end()) { @@ -238,7 +239,7 @@ BindResult TableBinding::Bind(ColumnRefExpression &colref, idx_t depth) { // fetch the type of the column LogicalType col_type; if (column_index == COLUMN_IDENTIFIER_ROW_ID) { - col_type = LogicalType::ROW_TYPE; + col_type = LogicalType(rowid_type); } else { // normal column: fetch type from base column col_type = types[column_index]; diff --git a/src/duckdb/src/storage/serialization/serialize_types.cpp b/src/duckdb/src/storage/serialization/serialize_types.cpp index dbbd0d455..34f48bdec 100644 --- a/src/duckdb/src/storage/serialization/serialize_types.cpp +++ b/src/duckdb/src/storage/serialization/serialize_types.cpp @@ -5,6 +5,7 @@ #include "duckdb/common/serializer/serializer.hpp" #include "duckdb/common/serializer/deserializer.hpp" +#include "duckdb/common/extension_type_info.hpp" #include "duckdb/common/extra_type_info.hpp" namespace duckdb { @@ -12,13 +13,15 @@ namespace duckdb { void ExtraTypeInfo::Serialize(Serializer &serializer) const { serializer.WriteProperty(100, "type", type); serializer.WritePropertyWithDefault(101, "alias", alias); - serializer.WritePropertyWithDefault>(102, "modifiers", modifiers, vector()); + /* [Deleted] (vector) "modifiers" */ + serializer.WritePropertyWithDefault>(103, "extension_info", extension_info); } shared_ptr ExtraTypeInfo::Deserialize(Deserializer &deserializer) { auto type = deserializer.ReadProperty(100, "type"); auto alias = deserializer.ReadPropertyWithDefault(101, "alias"); - auto modifiers = deserializer.ReadPropertyWithExplicitDefault>(102, "modifiers", vector()); + deserializer.ReadDeletedProperty>(102, "modifiers"); + auto extension_info = deserializer.ReadPropertyWithDefault>(103, "extension_info"); shared_ptr result; switch (type) { case ExtraTypeInfoType::AGGREGATE_STATE_TYPE_INFO: @@ -60,7 +63,7 @@ shared_ptr ExtraTypeInfo::Deserialize(Deserializer &deserializer) throw SerializationException("Unsupported type for deserialization of ExtraTypeInfo!"); } result->alias = std::move(alias); - result->modifiers = std::move(modifiers); + result->extension_info = std::move(extension_info); return result; } @@ -118,6 +121,18 @@ shared_ptr DecimalTypeInfo::Deserialize(Deserializer &deserialize return std::move(result); } +void ExtensionTypeInfo::Serialize(Serializer &serializer) const { + serializer.WritePropertyWithDefault>(100, "modifiers", modifiers); + serializer.WritePropertyWithDefault>(101, "properties", properties, unordered_map()); +} + +unique_ptr ExtensionTypeInfo::Deserialize(Deserializer &deserializer) { + auto result = duckdb::unique_ptr(new ExtensionTypeInfo()); + deserializer.ReadPropertyWithDefault>(100, "modifiers", result->modifiers); + deserializer.ReadPropertyWithExplicitDefault>(101, "properties", result->properties, unordered_map()); + return result; +} + void IntegerLiteralTypeInfo::Serialize(Serializer &serializer) const { ExtraTypeInfo::Serialize(serializer); serializer.WriteProperty(200, "constant_value", constant_value); @@ -167,7 +182,7 @@ void UserTypeInfo::Serialize(Serializer &serializer) const { 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, vector()); + serializer.WritePropertyWithDefault>(203, "user_type_modifiers", user_type_modifiers); } shared_ptr UserTypeInfo::Deserialize(Deserializer &deserializer) { @@ -175,7 +190,7 @@ shared_ptr UserTypeInfo::Deserialize(Deserializer &deserializer) 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.ReadPropertyWithExplicitDefault>(203, "user_type_modifiers", result->user_type_modifiers, vector()); + deserializer.ReadPropertyWithDefault>(203, "user_type_modifiers", result->user_type_modifiers); return std::move(result); } From 77c787ade47c237056ed67bf23c45eda60c30f33 Mon Sep 17 00:00:00 2001 From: DuckDB Labs GitHub Bot Date: Wed, 8 Jan 2025 00:34:13 +0000 Subject: [PATCH 06/16] Update vendored DuckDB sources to 0e3a5cb0 --- src/duckdb/src/common/exception.cpp | 1 - src/duckdb/src/common/stacktrace.cpp | 43 +- src/duckdb/src/common/types.cpp | 92 ++-- src/duckdb/src/common/types/vector.cpp | 54 +-- .../scanner/string_value_scanner.cpp | 43 +- .../state_machine/csv_state_machine_cache.cpp | 6 +- .../table_function/global_csv_state.cpp | 16 +- .../operator/csv_scanner/util/csv_error.cpp | 19 + .../csv_scanner/util/csv_reader_options.cpp | 27 +- .../operator/persistent/csv_rejects_table.cpp | 7 +- .../operator/persistent/physical_insert.cpp | 1 + .../src/execution/physical_plan/plan_cte.cpp | 2 +- src/duckdb/src/function/cast/struct_cast.cpp | 129 +++--- src/duckdb/src/function/table/sniff_csv.cpp | 8 +- .../function/table/version/pragma_version.cpp | 6 +- .../window/window_boundaries_state.cpp | 73 +++- .../function/window/window_rank_function.cpp | 29 +- .../window/window_rownumber_function.cpp | 12 +- .../function/window/window_value_function.cpp | 12 +- .../include/duckdb/common/types/vector.hpp | 7 +- .../operator/csv_scanner/csv_error.hpp | 9 +- .../operator/csv_scanner/global_csv_state.hpp | 2 +- .../duckdb/function/cast/bound_cast_data.hpp | 19 +- .../duckdb/function/compression_function.hpp | 4 +- .../storage/compression/alp/alp_compress.hpp | 21 +- .../compression/alprd/alprd_compress.hpp | 20 +- .../compression/chimp/chimp_compress.hpp | 2 +- .../compression/dictionary/compression.hpp | 4 +- .../compression/patas/patas_compress.hpp | 2 +- .../storage/compression/roaring/roaring.hpp | 4 +- .../duckdb/storage/segment/uncompressed.hpp | 2 +- .../table/column_data_checkpointer.hpp | 74 +++- src/duckdb/src/main/client_context.cpp | 4 +- .../optimizer/build_probe_side_optimizer.cpp | 6 +- src/duckdb/src/optimizer/filter_combiner.cpp | 24 +- .../binder/tableref/bind_table_function.cpp | 9 +- src/duckdb/src/storage/checkpoint_manager.cpp | 15 +- .../src/storage/compression/bitpacking.cpp | 22 +- .../compression/dictionary/compression.cpp | 20 +- .../compression/dictionary_compression.cpp | 6 +- .../compression/fixed_size_uncompressed.cpp | 25 +- src/duckdb/src/storage/compression/fsst.cpp | 22 +- src/duckdb/src/storage/compression/rle.cpp | 21 +- .../storage/compression/roaring/common.cpp | 4 +- .../storage/compression/roaring/compress.cpp | 14 +- src/duckdb/src/storage/compression/zstd.cpp | 26 +- src/duckdb/src/storage/table/column_data.cpp | 20 +- .../table/column_data_checkpointer.cpp | 404 ++++++++++++------ .../storage/table/standard_column_data.cpp | 25 +- 49 files changed, 945 insertions(+), 472 deletions(-) diff --git a/src/duckdb/src/common/exception.cpp b/src/duckdb/src/common/exception.cpp index 9b30eedb5..991f929f2 100644 --- a/src/duckdb/src/common/exception.cpp +++ b/src/duckdb/src/common/exception.cpp @@ -66,7 +66,6 @@ bool Exception::InvalidatesTransaction(ExceptionType exception_type) { bool Exception::InvalidatesDatabase(ExceptionType exception_type) { switch (exception_type) { - case ExceptionType::INTERNAL: case ExceptionType::FATAL: return true; default: diff --git a/src/duckdb/src/common/stacktrace.cpp b/src/duckdb/src/common/stacktrace.cpp index ab73be9f4..7a42b35cf 100644 --- a/src/duckdb/src/common/stacktrace.cpp +++ b/src/duckdb/src/common/stacktrace.cpp @@ -21,7 +21,7 @@ static string UnmangleSymbol(string symbol) { } } for (idx_t i = mangle_start; i < symbol.size(); i++) { - if (StringUtil::CharacterIsSpace(symbol[i])) { + if (StringUtil::CharacterIsSpace(symbol[i]) || symbol[i] == ')' || symbol[i] == '+') { mangle_end = i; break; } @@ -44,6 +44,45 @@ static string UnmangleSymbol(string symbol) { return result; } +static string CleanupStackTrace(string symbol) { +#ifdef __APPLE__ + // structure of frame pointers is [depth] [library] [pointer] [symbol] + // we are only interested in [depth] and [symbol] + + // find the depth + idx_t start; + for (start = 0; start < symbol.size(); start++) { + if (!StringUtil::CharacterIsDigit(symbol[start])) { + break; + } + } + + // now scan forward until we find the frame pointer + idx_t frame_end = symbol.size(); + for (idx_t i = start; i + 1 < symbol.size(); ++i) { + if (symbol[i] == '0' && symbol[i + 1] == 'x') { + idx_t k; + for (k = i + 2; k < symbol.size(); ++k) { + if (!StringUtil::CharacterIsHex(symbol[k])) { + break; + } + } + frame_end = k; + break; + } + } + static constexpr idx_t STACK_TRACE_INDENTATION = 8; + if (frame_end == symbol.size() || start >= STACK_TRACE_INDENTATION) { + // frame pointer not found - just preserve the original frame + return symbol; + } + idx_t space_count = STACK_TRACE_INDENTATION - start; + return symbol.substr(0, start) + string(space_count, ' ') + symbol.substr(frame_end, symbol.size() - frame_end); +#else + return symbol; +#endif +} + string StackTrace::GetStacktracePointers(idx_t max_depth) { string result; auto callstack = unique_ptr(new void *[max_depth]); @@ -68,7 +107,7 @@ string StackTrace::ResolveStacktraceSymbols(const string &pointers) { string result; char **strs = backtrace_symbols(callstack.get(), NumericCast(frame_count)); for (idx_t i = 0; i < frame_count; i++) { - result += UnmangleSymbol(strs[i]); + result += CleanupStackTrace(UnmangleSymbol(strs[i])); result += "\n"; } free(reinterpret_cast(strs)); diff --git a/src/duckdb/src/common/types.cpp b/src/duckdb/src/common/types.cpp index 52002ded4..4beade0ef 100644 --- a/src/duckdb/src/common/types.cpp +++ b/src/duckdb/src/common/types.cpp @@ -988,6 +988,72 @@ static bool CombineUnequalTypes(const LogicalType &left, const LogicalType &righ return false; } +template +static bool CombineStructTypes(const LogicalType &left, const LogicalType &right, LogicalType &result) { + auto &left_children = StructType::GetChildTypes(left); + auto &right_children = StructType::GetChildTypes(right); + + auto left_unnamed = StructType::IsUnnamed(left); + auto is_unnamed = left_unnamed || StructType::IsUnnamed(right); + child_list_t child_types; + + // At least one side is unnamed, so we attempt positional casting. + if (is_unnamed) { + if (left_children.size() != right_children.size()) { + // We can't cast, or create the super-set. + return false; + } + + for (idx_t i = 0; i < left_children.size(); i++) { + LogicalType child_type; + if (!OP::Operation(left_children[i].second, right_children[i].second, child_type)) { + return false; + } + auto &child_name = left_unnamed ? right_children[i].first : left_children[i].first; + child_types.emplace_back(child_name, std::move(child_type)); + } + result = LogicalType::STRUCT(child_types); + return true; + } + + // Create a super-set of the STRUCT fields. + // First, create a name->index map of the right children. + case_insensitive_map_t right_children_map; + for (idx_t i = 0; i < right_children.size(); i++) { + auto &name = right_children[i].first; + right_children_map[name] = i; + } + + for (idx_t i = 0; i < left_children.size(); i++) { + auto &left_child = left_children[i]; + auto right_child_it = right_children_map.find(left_child.first); + + if (right_child_it == right_children_map.end()) { + // We can directly put the left child. + child_types.emplace_back(left_child.first, left_child.second); + continue; + } + + // We need to recurse to ensure the children have a maximum logical type. + LogicalType child_type; + auto &right_child = right_children[right_child_it->second]; + if (!OP::Operation(left_child.second, right_child.second, child_type)) { + return false; + } + child_types.emplace_back(left_child.first, std::move(child_type)); + right_children_map.erase(right_child_it); + } + + // Add all remaining right children. + for (const auto &right_child_it : right_children_map) { + auto &right_child = right_children[right_child_it.second]; + child_types.emplace_back(right_child.first, right_child.second); + } + + result = LogicalType::STRUCT(child_types); + return true; +} + template static bool CombineEqualTypes(const LogicalType &left, const LogicalType &right, LogicalType &result) { // Since both left and right are equal we get the left type as our type_id for checks @@ -1059,31 +1125,7 @@ static bool CombineEqualTypes(const LogicalType &left, const LogicalType &right, return true; } case LogicalTypeId::STRUCT: { - // struct: perform recursively on each child - auto &left_child_types = StructType::GetChildTypes(left); - auto &right_child_types = StructType::GetChildTypes(right); - bool left_unnamed = StructType::IsUnnamed(left); - auto any_unnamed = left_unnamed || StructType::IsUnnamed(right); - if (left_child_types.size() != right_child_types.size()) { - // child types are not of equal size, we can't cast - // return false - return false; - } - child_list_t child_types; - for (idx_t i = 0; i < left_child_types.size(); i++) { - LogicalType child_type; - // Child names must be in the same order OR either one of the structs must be unnamed - if (!any_unnamed && !StringUtil::CIEquals(left_child_types[i].first, right_child_types[i].first)) { - return false; - } - if (!OP::Operation(left_child_types[i].second, right_child_types[i].second, child_type)) { - return false; - } - auto &child_name = left_unnamed ? right_child_types[i].first : left_child_types[i].first; - child_types.emplace_back(child_name, std::move(child_type)); - } - result = LogicalType::STRUCT(child_types); - return true; + return CombineStructTypes(left, right, result); } case LogicalTypeId::UNION: { auto left_member_count = UnionType::GetMemberCount(left); diff --git a/src/duckdb/src/common/types/vector.cpp b/src/duckdb/src/common/types/vector.cpp index 325246ad9..722b8b699 100644 --- a/src/duckdb/src/common/types/vector.cpp +++ b/src/duckdb/src/common/types/vector.cpp @@ -54,10 +54,10 @@ UnifiedVectorFormat &UnifiedVectorFormat::operator=(UnifiedVectorFormat &&other) return *this; } -Vector::Vector(LogicalType type_p, bool create_data, bool zero_data, idx_t capacity) +Vector::Vector(LogicalType type_p, bool create_data, bool initialize_to_zero, idx_t capacity) : vector_type(VectorType::FLAT_VECTOR), type(std::move(type_p)), data(nullptr), validity(capacity) { if (create_data) { - Initialize(zero_data, capacity); + Initialize(initialize_to_zero, capacity); } } @@ -306,7 +306,7 @@ void Vector::Slice(const SelectionVector &sel, idx_t count, SelCache &cache) { } } -void Vector::Initialize(bool zero_data, idx_t capacity) { +void Vector::Initialize(bool initialize_to_zero, idx_t capacity) { auxiliary.reset(); validity.Reset(); auto &type = GetType(); @@ -325,7 +325,7 @@ void Vector::Initialize(bool zero_data, idx_t capacity) { if (type_size > 0) { buffer = VectorBuffer::CreateStandardVector(type, capacity); data = buffer->GetData(); - if (zero_data) { + if (initialize_to_zero) { memset(data, 0, capacity * type_size); } } @@ -1374,10 +1374,10 @@ void Vector::Deserialize(Deserializer &deserializer, idx_t count) { } void Vector::SetVectorType(VectorType vector_type_p) { - this->vector_type = vector_type_p; + vector_type = vector_type_p; auto physical_type = GetType().InternalType(); - if (TypeIsConstantSize(physical_type) && - (GetVectorType() == VectorType::CONSTANT_VECTOR || GetVectorType() == VectorType::FLAT_VECTOR)) { + auto flat_or_const = GetVectorType() == VectorType::CONSTANT_VECTOR || GetVectorType() == VectorType::FLAT_VECTOR; + if (TypeIsConstantSize(physical_type) && flat_or_const) { auxiliary.reset(); } if (vector_type == VectorType::CONSTANT_VECTOR && physical_type == PhysicalType::STRUCT) { @@ -1782,23 +1782,29 @@ void Vector::DebugShuffleNestedVector(Vector &vector, idx_t count) { void FlatVector::SetNull(Vector &vector, idx_t idx, bool is_null) { D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR); vector.validity.Set(idx, !is_null); - if (is_null) { - auto &type = vector.GetType(); - auto internal_type = type.InternalType(); - if (internal_type == PhysicalType::STRUCT) { - // set all child entries to null as well - auto &entries = StructVector::GetEntries(vector); - for (auto &entry : entries) { - FlatVector::SetNull(*entry, idx, is_null); - } - } else if (internal_type == PhysicalType::ARRAY) { - // set the child element in the array to null as well - auto &child = ArrayVector::GetEntry(vector); - auto array_size = ArrayType::GetSize(type); - auto child_offset = idx * array_size; - for (idx_t i = 0; i < array_size; i++) { - FlatVector::SetNull(child, child_offset + i, is_null); - } + if (!is_null) { + return; + } + + auto &type = vector.GetType(); + auto internal_type = type.InternalType(); + + // Set all child entries to NULL. + if (internal_type == PhysicalType::STRUCT) { + auto &entries = StructVector::GetEntries(vector); + for (auto &entry : entries) { + FlatVector::SetNull(*entry, idx, is_null); + } + return; + } + + // Set all child entries to NULL. + if (internal_type == PhysicalType::ARRAY) { + auto &child = ArrayVector::GetEntry(vector); + auto array_size = ArrayType::GetSize(type); + auto child_offset = idx * array_size; + for (idx_t i = 0; i < array_size; i++) { + FlatVector::SetNull(child, child_offset + i, is_null); } } } diff --git a/src/duckdb/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp b/src/duckdb/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp index 7e3df336a..967660a8e 100644 --- a/src/duckdb/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp +++ b/src/duckdb/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp @@ -684,6 +684,19 @@ bool LineError::HandleErrors(StringValueResult &result) { result.state_machine.options, cur_error.current_line_size, lines_per_batch, borked_line, result.current_line_position.begin.GetGlobalPosition(result.requested_size, first_nl), result.path); break; + case INVALID_STATE: + if (result.current_line_position.begin == line_pos) { + csv_error = CSVError::InvalidState( + result.state_machine.options, col_idx, lines_per_batch, borked_line, + result.current_line_position.begin.GetGlobalPosition(result.requested_size, first_nl), + line_pos.GetGlobalPosition(result.requested_size, first_nl), result.path); + } else { + csv_error = CSVError::InvalidState( + result.state_machine.options, col_idx, lines_per_batch, borked_line, + result.current_line_position.begin.GetGlobalPosition(result.requested_size, first_nl), + line_pos.GetGlobalPosition(result.requested_size), result.path); + } + break; default: throw InvalidInputException("CSV Error not allowed when inserting row"); } @@ -878,7 +891,11 @@ bool StringValueResult::AddRow(StringValueResult &result, const idx_t buffer_pos } void StringValueResult::InvalidState(StringValueResult &result) { - result.current_errors.Insert(UNTERMINATED_QUOTES, result.cur_col_id, result.chunk_col_id, result.last_position); + if (result.quoted) { + result.current_errors.Insert(UNTERMINATED_QUOTES, result.cur_col_id, result.chunk_col_id, result.last_position); + } else { + result.current_errors.Insert(INVALID_STATE, result.cur_col_id, result.chunk_col_id, result.last_position); + } } bool StringValueResult::EmptyLine(StringValueResult &result, const idx_t buffer_pos) { @@ -1724,11 +1741,18 @@ void StringValueScanner::FinalizeChunkProcess() { // If we are not done we have two options. // 1) If a boundary is set. if (iterator.IsBoundarySet()) { - bool has_unterminated_quotes = false; - if (!result.current_errors.HasErrorType(UNTERMINATED_QUOTES)) { + bool found_error = false; + CSVErrorType type; + if (!result.current_errors.HasErrorType(UNTERMINATED_QUOTES) && + !result.current_errors.HasErrorType(INVALID_STATE)) { iterator.done = true; } else { - has_unterminated_quotes = true; + found_error = true; + if (result.current_errors.HasErrorType(UNTERMINATED_QUOTES)) { + type = UNTERMINATED_QUOTES; + } else { + type = INVALID_STATE; + } } // We read until the next line or until we have nothing else to read. // Move to next buffer @@ -1747,18 +1771,21 @@ void StringValueScanner::FinalizeChunkProcess() { } } else { if (result.current_errors.HasErrorType(UNTERMINATED_QUOTES)) { - has_unterminated_quotes = true; + found_error = true; + type = UNTERMINATED_QUOTES; + } else if (result.current_errors.HasErrorType(INVALID_STATE)) { + found_error = true; + type = INVALID_STATE; } if (result.current_errors.HandleErrors(result)) { result.number_of_rows++; } } - if (states.IsQuotedCurrent() && !has_unterminated_quotes && + if (states.IsQuotedCurrent() && !found_error && state_machine->dialect_options.state_machine_options.rfc_4180.GetValue()) { // If we finish the execution of a buffer, and we end in a quoted state, it means we have unterminated // quotes - result.current_errors.Insert(UNTERMINATED_QUOTES, result.cur_col_id, result.chunk_col_id, - result.last_position); + result.current_errors.Insert(type, result.cur_col_id, result.chunk_col_id, result.last_position); if (result.current_errors.HandleErrors(result)) { result.number_of_rows++; } diff --git a/src/duckdb/src/execution/operator/csv_scanner/state_machine/csv_state_machine_cache.cpp b/src/duckdb/src/execution/operator/csv_scanner/state_machine/csv_state_machine_cache.cpp index 99d863c74..29fda8863 100644 --- a/src/duckdb/src/execution/operator/csv_scanner/state_machine/csv_state_machine_cache.cpp +++ b/src/duckdb/src/execution/operator/csv_scanner/state_machine/csv_state_machine_cache.cpp @@ -75,10 +75,10 @@ void CSVStateMachineCache::Insert(const CSVStateMachineOptions &state_machine_op transition_array[static_cast('\r')][state] = CSVState::CARRIAGE_RETURN; if (state == static_cast(CSVState::STANDARD_NEWLINE)) { transition_array[static_cast('\n')][state] = CSVState::STANDARD; + } else if (!state_machine_options.rfc_4180.GetValue()) { + transition_array[static_cast('\n')][state] = CSVState::RECORD_SEPARATOR; } else { - if (!state_machine_options.rfc_4180.GetValue()) { - transition_array[static_cast('\n')][state] = CSVState::RECORD_SEPARATOR; - } + transition_array[static_cast('\n')][state] = CSVState::INVALID; } } else { transition_array[static_cast('\r')][state] = CSVState::RECORD_SEPARATOR; diff --git a/src/duckdb/src/execution/operator/csv_scanner/table_function/global_csv_state.cpp b/src/duckdb/src/execution/operator/csv_scanner/table_function/global_csv_state.cpp index 3874e74df..f6d0d386e 100644 --- a/src/duckdb/src/execution/operator/csv_scanner/table_function/global_csv_state.cpp +++ b/src/duckdb/src/execution/operator/csv_scanner/table_function/global_csv_state.cpp @@ -36,7 +36,7 @@ CSVGlobalState::CSVGlobalState(ClientContext &context_p, const shared_ptrstart_iterator; current_boundary.SetCurrentBoundaryToPosition(single_threaded); if (current_boundary.done && context.client_data->debug_set_max_line_length) { @@ -59,7 +59,7 @@ double CSVGlobalState::GetProgress(const ReadCSVData &bind_data_p) const { if (file_scans.front()->file_size == 0) { percentage = 1.0; } else { - // for compressed files, readed bytes may greater than files size. + // for compressed files, read bytes may greater than files size. for (auto &file : file_scans) { double file_progress; if (!file->buffer_manager) { @@ -73,7 +73,8 @@ double CSVGlobalState::GetProgress(const ReadCSVData &bind_data_p) const { file_progress = static_cast(file->bytes_read); } // This file is an uncompressed file, so we use the more price bytes_read from the scanner - percentage += (double(1) / double(total_files)) * std::min(1.0, file_progress / double(file->file_size)); + percentage += (static_cast(1) / static_cast(total_files)) * + std::min(1.0, file_progress / static_cast(file->file_size)); } } return percentage * 100; @@ -187,7 +188,7 @@ idx_t CSVGlobalState::MaxThreads() const { if (single_threaded || !file_scans.front()->on_disk_file) { return system_threads; } - idx_t total_threads = file_scans.front()->file_size / CSVIterator::BYTES_PER_THREAD + 1; + const idx_t total_threads = file_scans.front()->file_size / CSVIterator::BYTES_PER_THREAD + 1; if (total_threads < system_threads) { return total_threads; @@ -200,7 +201,7 @@ void CSVGlobalState::DecrementThread() { D_ASSERT(running_threads > 0); running_threads--; if (running_threads == 0) { - bool ignore_or_store_errors = + const bool ignore_or_store_errors = bind_data.options.ignore_errors.GetValue() || bind_data.options.store_rejects.GetValue(); if (!single_threaded && !ignore_or_store_errors) { // If we are running multithreaded and not ignoring errors, we must run the validator @@ -224,6 +225,7 @@ bool IsCSVErrorAcceptedReject(CSVErrorType type) { case CSVErrorType::MAXIMUM_LINE_SIZE: case CSVErrorType::UNTERMINATED_QUOTES: case CSVErrorType::INVALID_UNICODE: + case CSVErrorType::INVALID_STATE: return true; default: return false; @@ -244,6 +246,8 @@ string CSVErrorTypeToEnum(CSVErrorType type) { return "UNQUOTED VALUE"; case CSVErrorType::INVALID_UNICODE: return "INVALID UNICODE"; + case CSVErrorType::INVALID_STATE: + return "INVALID STATE"; default: throw InternalException("CSV Error is not valid to be stored in a Rejects Table"); } @@ -308,7 +312,7 @@ void FillScanErrorTable(InternalAppender &scan_appender, idx_t scan_idx, idx_t f scan_appender.EndRow(); } -void CSVGlobalState::FillRejectsTable() { +void CSVGlobalState::FillRejectsTable() const { auto &options = bind_data.options; if (options.store_rejects.GetValue()) { diff --git a/src/duckdb/src/execution/operator/csv_scanner/util/csv_error.cpp b/src/duckdb/src/execution/operator/csv_scanner/util/csv_error.cpp index cbb586441..5c01d1fe9 100644 --- a/src/duckdb/src/execution/operator/csv_scanner/util/csv_error.cpp +++ b/src/duckdb/src/execution/operator/csv_scanner/util/csv_error.cpp @@ -179,6 +179,20 @@ CSVError CSVError::LineSizeError(const CSVReaderOptions &options, idx_t actual_s how_to_fix_it.str(), current_path); } +CSVError CSVError::InvalidState(const CSVReaderOptions &options, idx_t current_column, LinesPerBoundary error_info, + string &csv_row, idx_t row_byte_position, optional_idx byte_position, + const string ¤t_path) { + std::ostringstream error; + error << "The CSV Parser state machine reached an invalid state.\nThis can happen when is not possible to parse " + "your CSV File with the given options, or the CSV File is not RFC 4180 compliant "; + + std::ostringstream how_to_fix_it; + how_to_fix_it << "Possible fixes:" << '\n'; + how_to_fix_it << "* Enable scanning files that are not RFC 4180 compliant (rfc_4180=false)." << '\n'; + + return CSVError(error.str(), INVALID_STATE, current_column, csv_row, error_info, row_byte_position, byte_position, + options, how_to_fix_it.str(), current_path); +} CSVError CSVError::HeaderSniffingError(const CSVReaderOptions &options, const vector &best_header_row, const idx_t column_count, const string &delimiter) { std::ostringstream error; @@ -228,6 +242,7 @@ CSVError CSVError::HeaderSniffingError(const CSVReaderOptions &options, const ve if (!options.null_padding) { error << "* Enable null padding (null_padding=true) to pad missing columns with NULL values" << '\n'; } + return CSVError(error.str(), SNIFFING, {}); } @@ -287,6 +302,10 @@ CSVError CSVError::SniffingError(const CSVReaderOptions &options, const string & error << "* Check you are using the correct file compression, otherwise set it (e.g., compression = \'zstd\')" << '\n'; + if (options.dialect_options.state_machine_options.rfc_4180.GetValue() != false || + !options.dialect_options.state_machine_options.rfc_4180.IsSetByUser()) { + error << "* Enable scanning files that are not RFC 4180 compliant (rfc_4180=false). " << '\n'; + } return CSVError(error.str(), SNIFFING, {}); } 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 2b05b242b..1a2ee65da 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 @@ -8,11 +8,11 @@ namespace duckdb { -CSVReaderOptions::CSVReaderOptions(CSVOption single_byte_delimiter, +CSVReaderOptions::CSVReaderOptions(const CSVOption single_byte_delimiter, const CSVOption &multi_byte_delimiter) { if (multi_byte_delimiter.GetValue().empty()) { - char single_byte_value = single_byte_delimiter.GetValue(); - string value(1, single_byte_value); + const char single_byte_value = single_byte_delimiter.GetValue(); + const string value(1, single_byte_value); dialect_options.state_machine_options.delimiter = value; } else { dialect_options.state_machine_options.delimiter = multi_byte_delimiter; @@ -32,7 +32,9 @@ static bool ParseBoolean(const vector &set, const string &loption) { } static bool ParseBoolean(const Value &value, const string &loption) { - + if (value.IsNull()) { + throw BinderException("\"%s\" expects a non-null boolean value (e.g. TRUE or 1)", loption); + } if (value.type().id() == LogicalTypeId::LIST) { auto &children = ListValue::GetChildren(value); return ParseBoolean(children, loption); @@ -62,6 +64,9 @@ static string ParseString(const Value &value, const string &loption) { } static int64_t ParseInteger(const Value &value, const string &loption) { + if (value.IsNull()) { + throw BinderException("\"%s\" expects a non-null integer value", loption); + } if (value.type().id() == LogicalTypeId::LIST) { auto &children = ListValue::GetChildren(value); if (children.size() != 1) { @@ -224,7 +229,7 @@ void CSVReaderOptions::SetReadOption(const string &loption, const Value &value, if (loption == "auto_detect") { auto_detect = ParseBoolean(value, loption); } else if (loption == "sample_size") { - auto sample_size_option = ParseInteger(value, loption); + const auto sample_size_option = ParseInteger(value, loption); if (sample_size_option < 1 && sample_size_option != -1) { throw BinderException("Unsupported parameter for SAMPLE_SIZE: cannot be smaller than 1"); } @@ -543,6 +548,13 @@ void CSVReaderOptions::Verify() { } } +bool GetBooleanValue(const pair &option) { + if (option.second.IsNull()) { + throw BinderException("read_csv %s cannot be NULL", option.first); + } + return BooleanValue::Get(option.second); +} + void CSVReaderOptions::FromNamedParameters(const named_parameter_map_t &in, ClientContext &context) { map ordered_user_defined_parameters; for (auto &kv : in) { @@ -672,9 +684,9 @@ void CSVReaderOptions::FromNamedParameters(const named_parameter_map_t &in, Clie sql_type_list.push_back(std::move(def_type)); } } else if (loption == "all_varchar") { - all_varchar = BooleanValue::Get(kv.second); + all_varchar = GetBooleanValue(kv); } else if (loption == "normalize_names") { - normalize_names = BooleanValue::Get(kv.second); + normalize_names = GetBooleanValue(kv); } else { SetReadOption(loption, kv.second, name_list); } @@ -686,7 +698,6 @@ void CSVReaderOptions::FromNamedParameters(const named_parameter_map_t &in, Clie user_defined_parameters.erase(user_defined_parameters.size() - 2); } } - //! This function is used to remember options set by the sniffer, for use in ReadCSVRelation void CSVReaderOptions::ToNamedParameters(named_parameter_map_t &named_params) const { auto &delimiter = dialect_options.state_machine_options.delimiter; diff --git a/src/duckdb/src/execution/operator/persistent/csv_rejects_table.cpp b/src/duckdb/src/execution/operator/persistent/csv_rejects_table.cpp index 11e8c1b0e..0674181f2 100644 --- a/src/duckdb/src/execution/operator/persistent/csv_rejects_table.cpp +++ b/src/duckdb/src/execution/operator/persistent/csv_rejects_table.cpp @@ -63,14 +63,17 @@ void CSVRejectsTable::InitializeTable(ClientContext &context, const ReadCSVData // Create CSV_ERROR_TYPE ENUM string enum_name = "CSV_ERROR_TYPE"; - Vector order_errors(LogicalType::VARCHAR, 6); + constexpr uint8_t number_of_accepted_errors = 7; + Vector order_errors(LogicalType::VARCHAR, number_of_accepted_errors); order_errors.SetValue(0, "CAST"); order_errors.SetValue(1, "MISSING COLUMNS"); order_errors.SetValue(2, "TOO MANY COLUMNS"); order_errors.SetValue(3, "UNQUOTED VALUE"); order_errors.SetValue(4, "LINE SIZE OVER MAXIMUM"); order_errors.SetValue(5, "INVALID UNICODE"); - LogicalType enum_type = LogicalType::ENUM(enum_name, order_errors, 6); + order_errors.SetValue(6, "INVALID STATE"); + + LogicalType enum_type = LogicalType::ENUM(enum_name, order_errors, number_of_accepted_errors); auto type_info = make_uniq(enum_name, enum_type); type_info->temporary = true; type_info->on_conflict = OnCreateConflict::IGNORE_ON_CONFLICT; diff --git a/src/duckdb/src/execution/operator/persistent/physical_insert.cpp b/src/duckdb/src/execution/operator/persistent/physical_insert.cpp index 736dffc9d..dac3491fe 100644 --- a/src/duckdb/src/execution/operator/persistent/physical_insert.cpp +++ b/src/duckdb/src/execution/operator/persistent/physical_insert.cpp @@ -712,6 +712,7 @@ SinkCombineResultType PhysicalInsert::Combine(ExecutionContext &context, Operato } else { // we have written rows to disk optimistically - merge directly into the transaction-local storage lstate.writer->WriteLastRowGroup(*lstate.local_collection); + lstate.writer->FinalFlush(); gstate.table.GetStorage().LocalMerge(context.client, *lstate.local_collection); gstate.table.GetStorage().FinalizeOptimisticWriter(context.client, *lstate.writer); } diff --git a/src/duckdb/src/execution/physical_plan/plan_cte.cpp b/src/duckdb/src/execution/physical_plan/plan_cte.cpp index 190cb9319..9c6596279 100644 --- a/src/duckdb/src/execution/physical_plan/plan_cte.cpp +++ b/src/duckdb/src/execution/physical_plan/plan_cte.cpp @@ -24,7 +24,7 @@ unique_ptr PhysicalPlanGenerator::CreatePlan(LogicalMaterializ auto right = CreatePlan(*op.children[1]); unique_ptr cte; - cte = make_uniq(op.ctename, op.table_index, op.children[1]->types, std::move(left), std::move(right), + cte = make_uniq(op.ctename, op.table_index, right->types, std::move(left), std::move(right), op.estimated_cardinality); cte->working_table = working_table; cte->cte_scans = materialized_ctes[op.table_index]; diff --git a/src/duckdb/src/function/cast/struct_cast.cpp b/src/duckdb/src/function/cast/struct_cast.cpp index 94f494c1c..e5902b752 100644 --- a/src/duckdb/src/function/cast/struct_cast.cpp +++ b/src/duckdb/src/function/cast/struct_cast.cpp @@ -1,3 +1,4 @@ +#include "duckdb/common/exception/binder_exception.hpp" #include "duckdb/function/cast/default_casts.hpp" #include "duckdb/function/cast/cast_function_set.hpp" #include "duckdb/function/cast/bound_cast_data.hpp" @@ -7,51 +8,67 @@ namespace duckdb { unique_ptr StructBoundCastData::BindStructToStructCast(BindCastInput &input, const LogicalType &source, const LogicalType &target) { vector child_cast_info; - auto &source_child_types = StructType::GetChildTypes(source); - auto &result_child_types = StructType::GetChildTypes(target); + auto &source_children = StructType::GetChildTypes(source); + auto &target_children = StructType::GetChildTypes(target); auto target_is_unnamed = StructType::IsUnnamed(target); auto source_is_unnamed = StructType::IsUnnamed(source); - if (source_child_types.size() != result_child_types.size()) { + auto is_unnamed = target_is_unnamed || source_is_unnamed; + if (is_unnamed && source_children.size() != target_children.size()) { throw TypeMismatchException(input.query_location, source, target, "Cannot cast STRUCTs of different size"); } - bool named_struct_cast = !source_is_unnamed && !target_is_unnamed; - case_insensitive_map_t target_members; - if (named_struct_cast) { - for (idx_t i = 0; i < result_child_types.size(); i++) { - auto &target_name = result_child_types[i].first; - if (target_members.find(target_name) != target_members.end()) { - throw NotImplementedException("Error while casting - duplicate name \"%s\" in struct", target_name); + + case_insensitive_map_t target_children_map; + if (!is_unnamed) { + for (idx_t i = 0; i < target_children.size(); i++) { + auto &name = target_children[i].first; + if (target_children_map.find(name) != target_children_map.end()) { + throw NotImplementedException("Error while casting - duplicate name \"%s\" in struct", name); } - target_members[target_name] = i; + target_children_map[name] = i; } } - vector child_member_map; - child_member_map.reserve(source_child_types.size()); - for (idx_t source_idx = 0; source_idx < source_child_types.size(); source_idx++) { - auto &source_child = source_child_types[source_idx]; - idx_t target_idx; - if (named_struct_cast) { - // named struct cast - find corresponding member in target - auto entry = target_members.find(source_child.first); - if (entry == target_members.end()) { - throw TypeMismatchException(input.query_location, source, target, - "Cannot cast STRUCTs - element \"" + source_child.first + - "\" in source struct was not found in target struct"); + + vector source_indexes; + vector target_indexes; + vector target_null_indexes; + bool has_any_match = is_unnamed; + + for (idx_t i = 0; i < source_children.size(); i++) { + auto &source_child = source_children[i]; + auto target_idx = i; + + // Map to the correct index for names structs. + if (!is_unnamed) { + auto target_child = target_children_map.find(source_child.first); + if (target_child == target_children_map.end()) { + // Skip any children that have no target. + continue; } - target_idx = entry->second; - target_members.erase(entry); - } else { - // unnamed struct cast - positionally cast elements - target_idx = source_idx; + target_idx = target_child->second; + target_children_map.erase(target_child); + has_any_match = true; } - child_member_map.push_back(target_idx); - auto child_cast = input.GetCastFunction(source_child.second, result_child_types[target_idx].second); + + source_indexes.push_back(i); + target_indexes.push_back(target_idx); + auto child_cast = input.GetCastFunction(source_child.second, target_children[target_idx].second); child_cast_info.push_back(std::move(child_cast)); } - D_ASSERT(child_member_map.size() == source_child_types.size()); - return make_uniq(std::move(child_cast_info), target, std::move(child_member_map)); + + if (!has_any_match) { + throw BinderException("STRUCT to STRUCT cast must have at least one matching member"); + } + + // The remaining target children have no match in the source struct. + // Thus, they become NULL. + for (const auto &target_child : target_children_map) { + target_null_indexes.push_back(target_child.second); + } + + return make_uniq(std::move(child_cast_info), target, std::move(source_indexes), + std::move(target_indexes), std::move(target_null_indexes)); } unique_ptr StructBoundCastData::InitStructCastLocalState(CastLocalStateParameters ¶meters) { @@ -71,32 +88,46 @@ unique_ptr StructBoundCastData::InitStructCastLocalState(Cas static bool StructToStructCast(Vector &source, Vector &result, idx_t count, CastParameters ¶meters) { auto &cast_data = parameters.cast_data->Cast(); - auto &lstate = parameters.local_state->Cast(); - auto &source_child_types = StructType::GetChildTypes(source.GetType()); - auto &source_children = StructVector::GetEntries(source); - D_ASSERT(source_children.size() == StructType::GetChildTypes(result.GetType()).size()); + auto &l_state = parameters.local_state->Cast(); + + auto &source_vectors = StructVector::GetEntries(source); + auto &target_children = StructVector::GetEntries(result); - auto &result_children = StructVector::GetEntries(result); bool all_converted = true; - for (idx_t c_idx = 0; c_idx < source_child_types.size(); c_idx++) { - auto source_idx = c_idx; - auto target_idx = cast_data.child_member_map[source_idx]; - auto &source_child_vector = *source_children[source_idx]; - auto &result_child_vector = *result_children[target_idx]; - CastParameters child_parameters(parameters, cast_data.child_cast_info[c_idx].cast_data, - lstate.local_states[c_idx]); - if (!cast_data.child_cast_info[c_idx].function(source_child_vector, result_child_vector, count, - child_parameters)) { + for (idx_t i = 0; i < cast_data.source_indexes.size(); i++) { + auto source_idx = cast_data.source_indexes[i]; + auto target_idx = cast_data.target_indexes[i]; + + auto &source_vector = *source_vectors[source_idx]; + auto &target_vector = *target_children[target_idx]; + + auto &child_cast_info = cast_data.child_cast_info[i]; + CastParameters child_parameters(parameters, child_cast_info.cast_data, l_state.local_states[i]); + auto success = child_cast_info.function(source_vector, target_vector, count, child_parameters); + if (!success) { all_converted = false; } } + + if (!cast_data.target_null_indexes.empty()) { + for (idx_t i = 0; i < cast_data.target_null_indexes.size(); i++) { + auto target_idx = cast_data.target_null_indexes[i]; + auto &target_vector = *target_children[target_idx]; + + target_vector.SetVectorType(VectorType::CONSTANT_VECTOR); + ConstantVector::SetNull(target_vector, true); + } + } + if (source.GetVectorType() == VectorType::CONSTANT_VECTOR) { result.SetVectorType(VectorType::CONSTANT_VECTOR); ConstantVector::SetNull(result, ConstantVector::IsNull(source)); - } else { - source.Flatten(count); - FlatVector::Validity(result) = FlatVector::Validity(source); + return all_converted; } + + source.Flatten(count); + auto &result_validity = FlatVector::Validity(result); + result_validity = FlatVector::Validity(source); return all_converted; } diff --git a/src/duckdb/src/function/table/sniff_csv.cpp b/src/duckdb/src/function/table/sniff_csv.cpp index c278dd723..5c72aabb9 100644 --- a/src/duckdb/src/function/table/sniff_csv.cpp +++ b/src/duckdb/src/function/table/sniff_csv.cpp @@ -38,9 +38,15 @@ static unique_ptr CSVSniffInitGlobal(ClientContext &co static unique_ptr CSVSniffBind(ClientContext &context, TableFunctionBindInput &input, vector &return_types, vector &names) { auto result = make_uniq(); + if (input.inputs[0].IsNull()) { + throw BinderException("sniff_csv cannot take NULL as a file path parameter"); + } result->path = input.inputs[0].ToString(); auto it = input.named_parameters.find("auto_detect"); if (it != input.named_parameters.end()) { + if (it->second.IsNull()) { + throw BinderException("\"%s\" expects a non-null boolean value (e.g. TRUE or 1)", it->first); + } if (!it->second.GetValue()) { throw InvalidInputException("sniff_csv function does not accept auto_detect variable set to false"); } @@ -169,7 +175,7 @@ static void CSVSniffFunction(ClientContext &context, TableFunctionInput &data_p, // 6. Skip Rows output.SetValue(5, 0, Value::UINTEGER(NumericCast(sniffer_options.dialect_options.skip_rows.GetValue()))); // 7. Has Header - auto has_header = Value::BOOLEAN(sniffer_options.dialect_options.header.GetValue()).ToString(); + auto has_header = Value::BOOLEAN(sniffer_options.dialect_options.header.GetValue()); output.SetValue(6, 0, has_header); // 8. List> {'col1': 'INTEGER', 'col2': 'VARCHAR'} vector values; diff --git a/src/duckdb/src/function/table/version/pragma_version.cpp b/src/duckdb/src/function/table/version/pragma_version.cpp index 167f071af..6bb466621 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 "4-dev3985" +#define DUCKDB_PATCH_VERSION "4-dev4108" #endif #ifndef DUCKDB_MINOR_VERSION #define DUCKDB_MINOR_VERSION 1 @@ -8,10 +8,10 @@ #define DUCKDB_MAJOR_VERSION 1 #endif #ifndef DUCKDB_VERSION -#define DUCKDB_VERSION "v1.1.4-dev3985" +#define DUCKDB_VERSION "v1.1.4-dev4108" #endif #ifndef DUCKDB_SOURCE_ID -#define DUCKDB_SOURCE_ID "adc6f607a7" +#define DUCKDB_SOURCE_ID "acdbf60889" #endif #include "duckdb/function/table/system_functions.hpp" #include "duckdb/main/database.hpp" diff --git a/src/duckdb/src/function/window/window_boundaries_state.cpp b/src/duckdb/src/function/window/window_boundaries_state.cpp index 234d0cadc..7727e2a63 100644 --- a/src/duckdb/src/function/window/window_boundaries_state.cpp +++ b/src/duckdb/src/function/window/window_boundaries_state.cpp @@ -301,51 +301,86 @@ WindowBoundsSet WindowBoundariesState::GetWindowBounds(const BoundWindowExpressi WindowBoundsSet result; switch (wexpr.GetExpressionType()) { case ExpressionType::WINDOW_ROW_NUMBER: - result.insert(PARTITION_BEGIN); - if (!wexpr.arg_orders.empty()) { - // Secondary orders need to know how wide the partition is + if (wexpr.arg_orders.empty()) { + result.insert(PARTITION_BEGIN); + } else { + // Secondary orders need to know where the frame is + result.insert(FRAME_BEGIN); + result.insert(FRAME_END); + } + break; + case ExpressionType::WINDOW_NTILE: + if (wexpr.arg_orders.empty()) { + result.insert(PARTITION_BEGIN); result.insert(PARTITION_END); + } else { + // Secondary orders need to know where the frame is + result.insert(FRAME_BEGIN); + result.insert(FRAME_END); } break; - case ExpressionType::WINDOW_RANK_DENSE: case ExpressionType::WINDOW_RANK: - result.insert(PARTITION_BEGIN); if (wexpr.arg_orders.empty()) { + result.insert(PARTITION_BEGIN); result.insert(PEER_BEGIN); } else { - // Secondary orders need to know how wide the partition is - result.insert(PARTITION_END); + // Secondary orders need to know where the frame is + result.insert(FRAME_BEGIN); + result.insert(FRAME_END); } break; - case ExpressionType::WINDOW_PERCENT_RANK: + case ExpressionType::WINDOW_RANK_DENSE: result.insert(PARTITION_BEGIN); - result.insert(PARTITION_END); + result.insert(PEER_BEGIN); + break; + case ExpressionType::WINDOW_PERCENT_RANK: if (wexpr.arg_orders.empty()) { - // Secondary orders need to know where the first peer is + result.insert(PARTITION_BEGIN); + result.insert(PARTITION_END); result.insert(PEER_BEGIN); + } else { + // Secondary orders need to know where the frame is + result.insert(FRAME_BEGIN); + result.insert(FRAME_END); } break; case ExpressionType::WINDOW_CUME_DIST: - result.insert(PARTITION_BEGIN); - result.insert(PARTITION_END); if (wexpr.arg_orders.empty()) { + result.insert(PARTITION_BEGIN); + result.insert(PARTITION_END); result.insert(PEER_END); + } else { + // Secondary orders need to know where the frame is + result.insert(FRAME_BEGIN); + result.insert(FRAME_END); } break; - case ExpressionType::WINDOW_NTILE: case ExpressionType::WINDOW_LEAD: case ExpressionType::WINDOW_LAG: - result.insert(PARTITION_BEGIN); - result.insert(PARTITION_END); + if (wexpr.arg_orders.empty()) { + result.insert(PARTITION_BEGIN); + result.insert(PARTITION_END); + } else { + // Secondary orders need to know where the frame is + result.insert(FRAME_BEGIN); + result.insert(FRAME_END); + } break; case ExpressionType::WINDOW_FIRST_VALUE: case ExpressionType::WINDOW_LAST_VALUE: case ExpressionType::WINDOW_NTH_VALUE: case ExpressionType::WINDOW_AGGREGATE: - result.insert(PARTITION_BEGIN); - result.insert(PARTITION_END); result.insert(FRAME_BEGIN); result.insert(FRAME_END); + break; + default: + throw InternalException("Window aggregate type %s", ExpressionTypeToString(wexpr.GetExpressionType())); + } + + // Internal dependencies + if (result.count(FRAME_BEGIN) || result.count(FRAME_END)) { + result.insert(PARTITION_BEGIN); + result.insert(PARTITION_END); // if we have EXCLUDE GROUP / TIES, we also need peer boundaries if (wexpr.exclude_clause != WindowExcludeMode::NO_OTHER) { @@ -389,12 +424,8 @@ WindowBoundsSet WindowBoundariesState::GetWindowBounds(const BoundWindowExpressi default: break; } - break; - default: - throw InternalException("Window aggregate type %s", ExpressionTypeToString(wexpr.GetExpressionType())); } - // Internal dependencies if (result.count(VALID_END)) { result.insert(PARTITION_END); if (HasFollowingRange(wexpr)) { diff --git a/src/duckdb/src/function/window/window_rank_function.cpp b/src/duckdb/src/function/window/window_rank_function.cpp index d1299430a..b71a4aeac 100644 --- a/src/duckdb/src/function/window/window_rank_function.cpp +++ b/src/duckdb/src/function/window/window_rank_function.cpp @@ -117,18 +117,19 @@ void WindowRankExecutor::EvaluateInternal(WindowExecutorGlobalState &gstate, Win DataChunk &eval_chunk, Vector &result, idx_t count, idx_t row_idx) const { auto &gpeer = gstate.Cast(); auto &lpeer = lstate.Cast(); - auto partition_begin = FlatVector::GetData(lpeer.bounds.data[PARTITION_BEGIN]); - auto partition_end = FlatVector::GetData(lpeer.bounds.data[PARTITION_END]); auto rdata = FlatVector::GetData(result); if (gpeer.token_tree) { + auto frame_begin = FlatVector::GetData(lpeer.bounds.data[FRAME_BEGIN]); + auto frame_end = FlatVector::GetData(lpeer.bounds.data[FRAME_END]); for (idx_t i = 0; i < count; ++i, ++row_idx) { - rdata[i] = gpeer.token_tree->Rank(partition_begin[i], partition_end[i], row_idx); + rdata[i] = gpeer.token_tree->Rank(frame_begin[i], frame_end[i], row_idx); } return; } // Reset to "previous" row + auto partition_begin = FlatVector::GetData(lpeer.bounds.data[PARTITION_BEGIN]); auto peer_begin = FlatVector::GetData(lpeer.bounds.data[PEER_BEGIN]); lpeer.rank = (peer_begin[0] - partition_begin[0]) + 1; lpeer.rank_equal = (row_idx - peer_begin[0]); @@ -215,14 +216,14 @@ void WindowPercentRankExecutor::EvaluateInternal(WindowExecutorGlobalState &gsta idx_t row_idx) const { auto &gpeer = gstate.Cast(); auto &lpeer = lstate.Cast(); - auto partition_begin = FlatVector::GetData(lpeer.bounds.data[PARTITION_BEGIN]); - auto partition_end = FlatVector::GetData(lpeer.bounds.data[PARTITION_END]); auto rdata = FlatVector::GetData(result); if (gpeer.token_tree) { + auto frame_begin = FlatVector::GetData(lpeer.bounds.data[FRAME_BEGIN]); + auto frame_end = FlatVector::GetData(lpeer.bounds.data[FRAME_END]); for (idx_t i = 0; i < count; ++i, ++row_idx) { - auto denom = static_cast(NumericCast(partition_end[i] - partition_begin[i] - 1)); - const auto rank = gpeer.token_tree->Rank(partition_begin[i], partition_end[i], row_idx); + auto denom = static_cast(NumericCast(frame_end[i] - frame_begin[i] - 1)); + const auto rank = gpeer.token_tree->Rank(frame_begin[i], frame_end[i], row_idx); double percent_rank = denom > 0 ? ((double)rank - 1) / denom : 0; rdata[i] = percent_rank; } @@ -230,6 +231,8 @@ void WindowPercentRankExecutor::EvaluateInternal(WindowExecutorGlobalState &gsta } // Reset to "previous" row + auto partition_begin = FlatVector::GetData(lpeer.bounds.data[PARTITION_BEGIN]); + auto partition_end = FlatVector::GetData(lpeer.bounds.data[PARTITION_END]); auto peer_begin = FlatVector::GetData(lpeer.bounds.data[PEER_BEGIN]); lpeer.rank = (peer_begin[0] - partition_begin[0]) + 1; lpeer.rank_equal = (row_idx - peer_begin[0]); @@ -254,20 +257,22 @@ void WindowCumeDistExecutor::EvaluateInternal(WindowExecutorGlobalState &gstate, DataChunk &eval_chunk, Vector &result, idx_t count, idx_t row_idx) const { auto &gpeer = gstate.Cast(); auto &lpeer = lstate.Cast(); - auto partition_begin = FlatVector::GetData(lpeer.bounds.data[PARTITION_BEGIN]); - auto partition_end = FlatVector::GetData(lpeer.bounds.data[PARTITION_END]); auto rdata = FlatVector::GetData(result); if (gpeer.token_tree) { + auto frame_begin = FlatVector::GetData(lpeer.bounds.data[FRAME_BEGIN]); + auto frame_end = FlatVector::GetData(lpeer.bounds.data[FRAME_END]); for (idx_t i = 0; i < count; ++i, ++row_idx) { - const auto denom = static_cast(NumericCast(partition_end[i] - partition_begin[i])); - const auto peer_end = gpeer.token_tree->PeerEnd(partition_begin[i], partition_end[i], row_idx); - const auto num = static_cast(peer_end - partition_begin[i]); + const auto denom = static_cast(NumericCast(frame_end[i] - frame_begin[i])); + const auto peer_end = gpeer.token_tree->PeerEnd(frame_begin[i], frame_end[i], row_idx); + const auto num = static_cast(peer_end - frame_begin[i]); rdata[i] = denom > 0 ? (num / denom) : 0; } return; } + auto partition_begin = FlatVector::GetData(lpeer.bounds.data[PARTITION_BEGIN]); + auto partition_end = FlatVector::GetData(lpeer.bounds.data[PARTITION_END]); auto peer_end = FlatVector::GetData(lpeer.bounds.data[PEER_END]); for (idx_t i = 0; i < count; ++i, ++row_idx) { const auto denom = static_cast(NumericCast(partition_end[i] - partition_begin[i])); diff --git a/src/duckdb/src/function/window/window_rownumber_function.cpp b/src/duckdb/src/function/window/window_rownumber_function.cpp index 71f27fa3d..5d766980f 100644 --- a/src/duckdb/src/function/window/window_rownumber_function.cpp +++ b/src/duckdb/src/function/window/window_rownumber_function.cpp @@ -97,18 +97,19 @@ void WindowRowNumberExecutor::EvaluateInternal(WindowExecutorGlobalState &gstate idx_t row_idx) const { auto &grstate = gstate.Cast(); auto &lrstate = lstate.Cast(); - auto partition_begin = FlatVector::GetData(lrstate.bounds.data[PARTITION_BEGIN]); auto rdata = FlatVector::GetData(result); if (grstate.token_tree) { - auto partition_end = FlatVector::GetData(lrstate.bounds.data[PARTITION_END]); + auto frame_begin = FlatVector::GetData(lrstate.bounds.data[FRAME_BEGIN]); + auto frame_end = FlatVector::GetData(lrstate.bounds.data[FRAME_END]); for (idx_t i = 0; i < count; ++i, ++row_idx) { // Row numbers are unique ranks - rdata[i] = grstate.token_tree->Rank(partition_begin[i], partition_end[i], row_idx); + rdata[i] = grstate.token_tree->Rank(frame_begin[i], frame_end[i], row_idx); } return; } + auto partition_begin = FlatVector::GetData(lrstate.bounds.data[PARTITION_BEGIN]); for (idx_t i = 0; i < count; ++i, ++row_idx) { rdata[i] = row_idx - partition_begin[i] + 1; } @@ -131,6 +132,11 @@ void WindowNtileExecutor::EvaluateInternal(WindowExecutorGlobalState &gstate, Wi auto &lrstate = lstate.Cast(); auto partition_begin = FlatVector::GetData(lrstate.bounds.data[PARTITION_BEGIN]); auto partition_end = FlatVector::GetData(lrstate.bounds.data[PARTITION_END]); + if (grstate.token_tree) { + // With secondary sorts, we restrict to the frame boundaries, but everything else should compute the same. + partition_begin = FlatVector::GetData(lrstate.bounds.data[FRAME_BEGIN]); + partition_end = FlatVector::GetData(lrstate.bounds.data[FRAME_END]); + } auto rdata = FlatVector::GetData(result); WindowInputExpression ntile_col(eval_chunk, ntile_idx); for (idx_t i = 0; i < count; ++i, ++row_idx) { diff --git a/src/duckdb/src/function/window/window_value_function.cpp b/src/duckdb/src/function/window/window_value_function.cpp index d6bd816f2..7639b3f16 100644 --- a/src/duckdb/src/function/window/window_value_function.cpp +++ b/src/duckdb/src/function/window/window_value_function.cpp @@ -273,22 +273,22 @@ WindowLeadLagExecutor::GetLocalState(const WindowExecutorGlobalState &gstate) co void WindowLeadLagExecutor::EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate, DataChunk &eval_chunk, Vector &result, idx_t count, idx_t row_idx) const { auto &glstate = gstate.Cast(); - auto &ignore_nulls = glstate.ignore_nulls; auto &llstate = lstate.Cast(); auto &cursor = *llstate.cursor; WindowInputExpression leadlag_offset(eval_chunk, offset_idx); WindowInputExpression leadlag_default(eval_chunk, default_idx); - auto partition_begin = FlatVector::GetData(llstate.bounds.data[PARTITION_BEGIN]); - auto partition_end = FlatVector::GetData(llstate.bounds.data[PARTITION_END]); if (glstate.row_tree) { + auto frame_begin = FlatVector::GetData(llstate.bounds.data[FRAME_BEGIN]); + auto frame_end = FlatVector::GetData(llstate.bounds.data[FRAME_END]); + // TODO: Handle subframes. auto &frames = llstate.frames; frames.resize(1); auto &frame = frames[0]; for (idx_t i = 0; i < count; ++i, ++row_idx) { // (1) compute the ROW_NUMBER of the own row - frame = FrameBounds(partition_begin[i], partition_end[i]); + frame = FrameBounds(frame_begin[i], frame_end[i]); const auto own_row = glstate.row_tree->Rank(frame.start, frame.end, row_idx) - 1; // (2) adjust the row number by adding or subtracting an offset auto val_idx = NumericCast(own_row); @@ -317,6 +317,10 @@ void WindowLeadLagExecutor::EvaluateInternal(WindowExecutorGlobalState &gstate, return; } + auto partition_begin = FlatVector::GetData(llstate.bounds.data[PARTITION_BEGIN]); + auto partition_end = FlatVector::GetData(llstate.bounds.data[PARTITION_END]); + + auto &ignore_nulls = glstate.ignore_nulls; bool can_shift = ignore_nulls->AllValid(); if (wexpr.offset_expr) { can_shift = can_shift && wexpr.offset_expr->IsFoldable(); diff --git a/src/duckdb/src/include/duckdb/common/types/vector.hpp b/src/duckdb/src/include/duckdb/common/types/vector.hpp index 067582f45..61e0b714e 100644 --- a/src/duckdb/src/include/duckdb/common/types/vector.hpp +++ b/src/duckdb/src/include/duckdb/common/types/vector.hpp @@ -109,9 +109,10 @@ class Vector { /*! Create a new vector If create_data is true, the vector will be an owning empty vector. - If zero_data is true, the allocated data will be zero-initialized. + If initialize_to_zero is true, the allocated data will be zero-initialized. */ - DUCKDB_API Vector(LogicalType type, bool create_data, bool zero_data, idx_t capacity = STANDARD_VECTOR_SIZE); + DUCKDB_API Vector(LogicalType type, bool create_data, bool initialize_to_zero, + idx_t capacity = STANDARD_VECTOR_SIZE); // implicit copying of Vectors is not allowed Vector(const Vector &) = delete; // but moving of vectors is allowed @@ -151,7 +152,7 @@ class Vector { //! Creates the data of this vector with the specified type. Any data that //! is currently in the vector is destroyed. - DUCKDB_API void Initialize(bool zero_data = false, idx_t capacity = STANDARD_VECTOR_SIZE); + DUCKDB_API void Initialize(bool initialize_to_zero = false, idx_t capacity = STANDARD_VECTOR_SIZE); //! Converts this Vector to a printable string representation DUCKDB_API string ToString(idx_t count) const; diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_error.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_error.hpp index f7acbcb9e..6dd8a22ec 100644 --- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_error.hpp +++ b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_error.hpp @@ -45,7 +45,8 @@ enum CSVErrorType : uint8_t { SNIFFING = 5, //! If something went wrong during sniffing and was not possible to find suitable candidates MAXIMUM_LINE_SIZE = 6, //! Maximum line size was exceeded by a line in the CSV File NULLPADDED_QUOTED_NEW_VALUE = 7, //! If the null_padding option is set, and we have quoted new values in parallel - INVALID_UNICODE = 8 //! If we have invalid unicode values + INVALID_UNICODE = 8, //! If we have invalid unicode values + INVALID_STATE = 9 //! If our CSV Scanner ended up in an invalid state }; class CSVError { @@ -64,6 +65,10 @@ class CSVError { //! Produces error for when the line size exceeds the maximum line size option static CSVError LineSizeError(const CSVReaderOptions &options, idx_t actual_size, LinesPerBoundary error_info, string &csv_row, idx_t byte_position, const string ¤t_path); + //! Produces error for when the state machine reaches an invalid state + static CSVError InvalidState(const CSVReaderOptions &options, idx_t current_column, LinesPerBoundary error_info, + string &csv_row, idx_t row_byte_position, optional_idx byte_position, + const string ¤t_path); //! Produces an error message for a dialect sniffing error. static CSVError SniffingError(const CSVReaderOptions &options, const string &search_space); //! Produces an error message for a header sniffing error. @@ -73,7 +78,7 @@ class CSVError { static CSVError UnterminatedQuotesError(const CSVReaderOptions &options, idx_t current_column, LinesPerBoundary error_info, string &csv_row, idx_t row_byte_position, optional_idx byte_position, const string ¤t_path); - //! Produces error messages for null_padding option is set and we have quoted new values in parallel + //! Produces error messages for null_padding option is set, and we have quoted new values in parallel static CSVError NullPaddingFail(const CSVReaderOptions &options, LinesPerBoundary error_info, const string ¤t_path); //! Produces error for incorrect (e.g., smaller and lower than the predefined) number of columns in a CSV Line diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/global_csv_state.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/global_csv_state.hpp index 2f63d9453..5381071ab 100644 --- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/global_csv_state.hpp +++ b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/global_csv_state.hpp @@ -32,7 +32,7 @@ struct CSVGlobalState : public GlobalTableFunctionState { //! In case it returns a nullptr it means we are done reading these files. unique_ptr Next(optional_ptr previous_scanner); - void FillRejectsTable(); + void FillRejectsTable() const; void DecrementThread(); diff --git a/src/duckdb/src/include/duckdb/function/cast/bound_cast_data.hpp b/src/duckdb/src/include/duckdb/function/cast/bound_cast_data.hpp index 50b4c70ab..fe950d0d1 100644 --- a/src/duckdb/src/include/duckdb/function/cast/bound_cast_data.hpp +++ b/src/duckdb/src/include/duckdb/function/cast/bound_cast_data.hpp @@ -48,21 +48,27 @@ struct ListCast { }; struct StructBoundCastData : public BoundCastData { - StructBoundCastData(vector child_casts, LogicalType target_p, vector child_member_map_p) + StructBoundCastData(vector child_casts, LogicalType target_p, vector source_indexes_p, + vector target_indexes_p, vector target_null_indexes_p) : child_cast_info(std::move(child_casts)), target(std::move(target_p)), - child_member_map(std::move(child_member_map_p)) { - D_ASSERT(child_cast_info.size() == child_member_map.size()); + source_indexes(std::move(source_indexes_p)), target_indexes(std::move(target_indexes_p)), + target_null_indexes(std::move(target_null_indexes_p)) { + D_ASSERT(child_cast_info.size() == source_indexes.size()); + D_ASSERT(source_indexes.size() == target_indexes.size()); } StructBoundCastData(vector child_casts, LogicalType target_p) : child_cast_info(std::move(child_casts)), target(std::move(target_p)) { for (idx_t i = 0; i < child_cast_info.size(); i++) { - child_member_map.push_back(i); + source_indexes.push_back(i); + target_indexes.push_back(i); } } vector child_cast_info; LogicalType target; - vector child_member_map; + vector source_indexes; + vector target_indexes; + vector target_null_indexes; static unique_ptr BindStructToStructCast(BindCastInput &input, const LogicalType &source, const LogicalType &target); @@ -74,7 +80,8 @@ struct StructBoundCastData : public BoundCastData { for (auto &info : child_cast_info) { copy_info.push_back(info.Copy()); } - return make_uniq(std::move(copy_info), target, child_member_map); + return make_uniq(std::move(copy_info), target, source_indexes, target_indexes, + target_null_indexes); } }; diff --git a/src/duckdb/src/include/duckdb/function/compression_function.hpp b/src/duckdb/src/include/duckdb/function/compression_function.hpp index 9199f45ac..d11beaa72 100644 --- a/src/duckdb/src/include/duckdb/function/compression_function.hpp +++ b/src/duckdb/src/include/duckdb/function/compression_function.hpp @@ -19,7 +19,7 @@ namespace duckdb { class DatabaseInstance; class ColumnData; -class ColumnDataCheckpointer; +struct ColumnDataCheckpointData; class ColumnSegment; class SegmentStatistics; class TableFilter; @@ -152,7 +152,7 @@ typedef idx_t (*compression_final_analyze_t)(AnalyzeState &state); //===--------------------------------------------------------------------===// // Compress //===--------------------------------------------------------------------===// -typedef unique_ptr (*compression_init_compression_t)(ColumnDataCheckpointer &checkpointer, +typedef unique_ptr (*compression_init_compression_t)(ColumnDataCheckpointData &checkpoint_data, unique_ptr state); typedef void (*compression_compress_data_t)(CompressionState &state, Vector &scan_vector, idx_t count); typedef void (*compression_compress_finalize_t)(CompressionState &state); diff --git a/src/duckdb/src/include/duckdb/storage/compression/alp/alp_compress.hpp b/src/duckdb/src/include/duckdb/storage/compression/alp/alp_compress.hpp index 2fad85771..5ba58dcf6 100644 --- a/src/duckdb/src/include/duckdb/storage/compression/alp/alp_compress.hpp +++ b/src/duckdb/src/include/duckdb/storage/compression/alp/alp_compress.hpp @@ -32,16 +32,16 @@ struct AlpCompressionState : public CompressionState { public: using EXACT_TYPE = typename FloatingToExact::TYPE; - AlpCompressionState(ColumnDataCheckpointer &checkpointer, AlpAnalyzeState *analyze_state) - : CompressionState(analyze_state->info), checkpointer(checkpointer), - function(checkpointer.GetCompressionFunction(CompressionType::COMPRESSION_ALP)) { - CreateEmptySegment(checkpointer.GetRowGroup().start); + AlpCompressionState(ColumnDataCheckpointData &checkpoint_data, AlpAnalyzeState *analyze_state) + : CompressionState(analyze_state->info), checkpoint_data(checkpoint_data), + function(checkpoint_data.GetCompressionFunction(CompressionType::COMPRESSION_ALP)) { + CreateEmptySegment(checkpoint_data.GetRowGroup().start); //! Combinations found on the analyze step are needed for compression state.best_k_combinations = analyze_state->state.best_k_combinations; } - ColumnDataCheckpointer &checkpointer; + ColumnDataCheckpointData &checkpoint_data; CompressionFunction &function; unique_ptr current_segment; BufferHandle handle; @@ -90,8 +90,8 @@ struct AlpCompressionState : public CompressionState { } void CreateEmptySegment(idx_t row_start) { - auto &db = checkpointer.GetDatabase(); - auto &type = checkpointer.GetType(); + auto &db = checkpoint_data.GetDatabase(); + auto &type = checkpoint_data.GetType(); auto compressed_segment = ColumnSegment::CreateTransientSegment(db, function, type, row_start, info.GetBlockSize(), info.GetBlockSize()); @@ -176,7 +176,7 @@ struct AlpCompressionState : public CompressionState { } void FlushSegment() { - auto &checkpoint_state = checkpointer.GetCheckpointState(); + auto &checkpoint_state = checkpoint_data.GetCheckpointState(); auto dataptr = handle.Ptr(); idx_t metadata_offset = AlignValue(UsedSpace()); @@ -262,8 +262,9 @@ struct AlpCompressionState : public CompressionState { }; template -unique_ptr AlpInitCompression(ColumnDataCheckpointer &checkpointer, unique_ptr state) { - return make_uniq>(checkpointer, (AlpAnalyzeState *)state.get()); +unique_ptr AlpInitCompression(ColumnDataCheckpointData &checkpoint_data, + unique_ptr state) { + return make_uniq>(checkpoint_data, (AlpAnalyzeState *)state.get()); } template diff --git a/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_compress.hpp b/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_compress.hpp index e5e8043d7..6b732e664 100644 --- a/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_compress.hpp +++ b/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_compress.hpp @@ -34,9 +34,9 @@ struct AlpRDCompressionState : public CompressionState { public: using EXACT_TYPE = typename FloatingToExact::TYPE; - AlpRDCompressionState(ColumnDataCheckpointer &checkpointer, AlpRDAnalyzeState *analyze_state) - : CompressionState(analyze_state->info), checkpointer(checkpointer), - function(checkpointer.GetCompressionFunction(CompressionType::COMPRESSION_ALPRD)) { + AlpRDCompressionState(ColumnDataCheckpointData &checkpoint_data, AlpRDAnalyzeState *analyze_state) + : CompressionState(analyze_state->info), checkpoint_data(checkpoint_data), + function(checkpoint_data.GetCompressionFunction(CompressionType::COMPRESSION_ALPRD)) { //! State variables from the analyze step that are needed for compression state.left_parts_dict_map = std::move(analyze_state->state.left_parts_dict_map); state.left_bit_width = analyze_state->state.left_bit_width; @@ -46,10 +46,10 @@ struct AlpRDCompressionState : public CompressionState { next_vector_byte_index_start = AlpRDConstants::HEADER_SIZE + actual_dictionary_size_bytes; memcpy((void *)state.left_parts_dict, (void *)analyze_state->state.left_parts_dict, actual_dictionary_size_bytes); - CreateEmptySegment(checkpointer.GetRowGroup().start); + CreateEmptySegment(checkpoint_data.GetRowGroup().start); } - ColumnDataCheckpointer &checkpointer; + ColumnDataCheckpointData &checkpoint_data; CompressionFunction &function; unique_ptr current_segment; BufferHandle handle; @@ -100,8 +100,8 @@ struct AlpRDCompressionState : public CompressionState { } void CreateEmptySegment(idx_t row_start) { - auto &db = checkpointer.GetDatabase(); - auto &type = checkpointer.GetType(); + auto &db = checkpoint_data.GetDatabase(); + auto &type = checkpoint_data.GetType(); auto compressed_segment = ColumnSegment::CreateTransientSegment(db, function, type, row_start, info.GetBlockSize(), info.GetBlockSize()); @@ -176,7 +176,7 @@ struct AlpRDCompressionState : public CompressionState { } void FlushSegment() { - auto &checkpoint_state = checkpointer.GetCheckpointState(); + auto &checkpoint_state = checkpoint_data.GetCheckpointState(); auto dataptr = handle.Ptr(); idx_t metadata_offset = AlignValue(UsedSpace()); @@ -277,9 +277,9 @@ struct AlpRDCompressionState : public CompressionState { }; template -unique_ptr AlpRDInitCompression(ColumnDataCheckpointer &checkpointer, +unique_ptr AlpRDInitCompression(ColumnDataCheckpointData &checkpoint_data, unique_ptr state) { - return make_uniq>(checkpointer, (AlpRDAnalyzeState *)state.get()); + return make_uniq>(checkpoint_data, (AlpRDAnalyzeState *)state.get()); } template diff --git a/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp_compress.hpp b/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp_compress.hpp index a233246f3..ae120027c 100644 --- a/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp_compress.hpp +++ b/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp_compress.hpp @@ -33,7 +33,7 @@ struct ChimpCompressionState : public CompressionState {}; // Compression Functions template -unique_ptr ChimpInitCompression(ColumnDataCheckpointer &checkpointer, +unique_ptr ChimpInitCompression(ColumnDataCheckpointData &checkpoint_data, unique_ptr state) { throw InternalException("Chimp has been deprecated, can no longer be used to compress data"); return nullptr; diff --git a/src/duckdb/src/include/duckdb/storage/compression/dictionary/compression.hpp b/src/duckdb/src/include/duckdb/storage/compression/dictionary/compression.hpp index 1ffdb494b..b0f29dc59 100644 --- a/src/duckdb/src/include/duckdb/storage/compression/dictionary/compression.hpp +++ b/src/duckdb/src/include/duckdb/storage/compression/dictionary/compression.hpp @@ -23,7 +23,7 @@ namespace duckdb { //===--------------------------------------------------------------------===// struct DictionaryCompressionCompressState : public DictionaryCompressionState { public: - DictionaryCompressionCompressState(ColumnDataCheckpointer &checkpointer_p, const CompressionInfo &info); + DictionaryCompressionCompressState(ColumnDataCheckpointData &checkpoint_data_p, const CompressionInfo &info); public: void CreateEmptySegment(idx_t row_start); @@ -37,7 +37,7 @@ struct DictionaryCompressionCompressState : public DictionaryCompressionState { idx_t Finalize(); public: - ColumnDataCheckpointer &checkpointer; + ColumnDataCheckpointData &checkpoint_data; CompressionFunction &function; // State regarding current segment diff --git a/src/duckdb/src/include/duckdb/storage/compression/patas/patas_compress.hpp b/src/duckdb/src/include/duckdb/storage/compression/patas/patas_compress.hpp index 2931e9168..b33e1a6a0 100644 --- a/src/duckdb/src/include/duckdb/storage/compression/patas/patas_compress.hpp +++ b/src/duckdb/src/include/duckdb/storage/compression/patas/patas_compress.hpp @@ -35,7 +35,7 @@ struct PatasCompressionState : public CompressionState {}; // Compression Functions template -unique_ptr PatasInitCompression(ColumnDataCheckpointer &checkpointer, +unique_ptr PatasInitCompression(ColumnDataCheckpointData &checkpoint_data, unique_ptr state) { throw InternalException("Patas has been deprecated, can no longer be used to compress data"); return nullptr; diff --git a/src/duckdb/src/include/duckdb/storage/compression/roaring/roaring.hpp b/src/duckdb/src/include/duckdb/storage/compression/roaring/roaring.hpp index 86bb985d4..7a2d1ddaa 100644 --- a/src/duckdb/src/include/duckdb/storage/compression/roaring/roaring.hpp +++ b/src/duckdb/src/include/duckdb/storage/compression/roaring/roaring.hpp @@ -319,7 +319,7 @@ struct ContainerCompressionState { struct RoaringCompressState : public CompressionState { public: - explicit RoaringCompressState(ColumnDataCheckpointer &checkpointer, unique_ptr analyze_state_p); + explicit RoaringCompressState(ColumnDataCheckpointData &checkpoint_data, unique_ptr analyze_state_p); public: //! RoaringStateAppender interface @@ -350,7 +350,7 @@ struct RoaringCompressState : public CompressionState { ContainerMetadataCollection metadata_collection; vector &container_metadata; - ColumnDataCheckpointer &checkpointer; + ColumnDataCheckpointData &checkpoint_data; CompressionFunction &function; unique_ptr current_segment; BufferHandle handle; diff --git a/src/duckdb/src/include/duckdb/storage/segment/uncompressed.hpp b/src/duckdb/src/include/duckdb/storage/segment/uncompressed.hpp index 7452c8ed9..fb6dd6c0e 100644 --- a/src/duckdb/src/include/duckdb/storage/segment/uncompressed.hpp +++ b/src/duckdb/src/include/duckdb/storage/segment/uncompressed.hpp @@ -14,7 +14,7 @@ namespace duckdb { class DatabaseInstance; struct UncompressedFunctions { - static unique_ptr InitCompression(ColumnDataCheckpointer &checkpointer, + static unique_ptr InitCompression(ColumnDataCheckpointData &checkpoint_data, unique_ptr state); static void Compress(CompressionState &state_p, Vector &data, idx_t count); static void FinalizeCompress(CompressionState &state_p); diff --git a/src/duckdb/src/include/duckdb/storage/table/column_data_checkpointer.hpp b/src/duckdb/src/include/duckdb/storage/table/column_data_checkpointer.hpp index 2bdc41dd8..a5bd436bb 100644 --- a/src/duckdb/src/include/duckdb/storage/table/column_data_checkpointer.hpp +++ b/src/duckdb/src/include/duckdb/storage/table/column_data_checkpointer.hpp @@ -15,38 +15,78 @@ namespace duckdb { struct TableScanOptions; -class ColumnDataCheckpointer { +//! Holds state related to a single column during compression +struct ColumnDataCheckpointData { public: - ColumnDataCheckpointer(ColumnData &col_data_p, RowGroup &row_group_p, ColumnCheckpointState &state_p, - ColumnCheckpointInfo &checkpoint_info); + //! Default constructor used when column data does not need to be checkpointed + ColumnDataCheckpointData() { + } + ColumnDataCheckpointData(ColumnCheckpointState &checkpoint_state, ColumnData &col_data, DatabaseInstance &db, + RowGroup &row_group, ColumnCheckpointInfo &checkpoint_info) + : checkpoint_state(checkpoint_state), col_data(col_data), db(db), row_group(row_group), + checkpoint_info(checkpoint_info) { + } public: - DatabaseInstance &GetDatabase(); + CompressionFunction &GetCompressionFunction(CompressionType type); const LogicalType &GetType() const; ColumnData &GetColumnData(); RowGroup &GetRowGroup(); ColumnCheckpointState &GetCheckpointState(); + DatabaseInstance &GetDatabase(); - void Checkpoint(const column_segment_vector_t &nodes); - void FinalizeCheckpoint(column_segment_vector_t &&nodes); - CompressionFunction &GetCompressionFunction(CompressionType type); +private: + optional_ptr checkpoint_state; + optional_ptr col_data; + optional_ptr db; + optional_ptr row_group; + optional_ptr checkpoint_info; +}; + +struct CheckpointAnalyzeResult { +public: + //! Default constructor, returned when the column data doesn't require checkpoint + CheckpointAnalyzeResult() { + } + CheckpointAnalyzeResult(unique_ptr &&analyze_state, CompressionFunction &function) + : analyze_state(std::move(analyze_state)), function(function) { + } + +public: + unique_ptr analyze_state; + optional_ptr function; +}; + +class ColumnDataCheckpointer { +public: + ColumnDataCheckpointer(vector> &states, DatabaseInstance &db, RowGroup &row_group, + ColumnCheckpointInfo &checkpoint_info); + +public: + void Checkpoint(); + void FinalizeCheckpoint(); private: - void ScanSegments(const column_segment_vector_t &nodes, const std::function &callback); - unique_ptr DetectBestCompressionMethod(const column_segment_vector_t &nodes, idx_t &compression_idx); - void WriteToDisk(const column_segment_vector_t &nodes); - bool HasChanges(const column_segment_vector_t &nodes); - void WritePersistentSegments(column_segment_vector_t nodes); + void ScanSegments(const std::function &callback); + vector DetectBestCompressionMethod(); + void WriteToDisk(); + bool HasChanges(ColumnData &col_data); + void WritePersistentSegments(ColumnCheckpointState &state); + void InitAnalyze(); + void DropSegments(); private: - ColumnData &col_data; + vector> &checkpoint_states; + DatabaseInstance &db; RowGroup &row_group; - ColumnCheckpointState &state; - bool is_validity; - bool has_changes; Vector intermediate; - vector> compression_functions; ColumnCheckpointInfo &checkpoint_info; + + vector has_changes; + //! For every column data that is being checkpointed, the applicable functions + vector>> compression_functions; + //! For every column data that is being checkpointed, the analyze state of functions being tried + vector>> analyze_states; }; } // namespace duckdb diff --git a/src/duckdb/src/main/client_context.cpp b/src/duckdb/src/main/client_context.cpp index 94e413717..53234bdb9 100644 --- a/src/duckdb/src/main/client_context.cpp +++ b/src/duckdb/src/main/client_context.cpp @@ -236,7 +236,7 @@ ErrorData ClientContext::EndQueryInternal(ClientContextLock &lock, bool success, } } catch (std::exception &ex) { error = ErrorData(ex); - if (Exception::InvalidatesDatabase(error.Type())) { + if (Exception::InvalidatesDatabase(error.Type()) || error.Type() == ExceptionType::INTERNAL) { auto &db_inst = DatabaseInstance::GetDatabase(*this); ValidChecker::Invalidate(db_inst, error.RawMessage()); } @@ -584,7 +584,7 @@ PendingExecutionResult ClientContext::ExecuteTaskInternal(ClientContextLock &loc } } else if (!Exception::InvalidatesTransaction(error.Type())) { invalidate_transaction = false; - } else if (Exception::InvalidatesDatabase(error.Type())) { + } else if (Exception::InvalidatesDatabase(error.Type()) || error.Type() == ExceptionType::INTERNAL) { // fatal exceptions invalidate the entire database auto &db_instance = DatabaseInstance::GetDatabase(*this); ValidChecker::Invalidate(db_instance, error.RawMessage()); diff --git a/src/duckdb/src/optimizer/build_probe_side_optimizer.cpp b/src/duckdb/src/optimizer/build_probe_side_optimizer.cpp index efd21ed20..384760594 100644 --- a/src/duckdb/src/optimizer/build_probe_side_optimizer.cpp +++ b/src/duckdb/src/optimizer/build_probe_side_optimizer.cpp @@ -54,8 +54,7 @@ static void FlipChildren(LogicalOperator &op) { std::swap(op.children[0], op.children[1]); switch (op.type) { case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: - case LogicalOperatorType::LOGICAL_DELIM_JOIN: - case LogicalOperatorType::LOGICAL_ASOF_JOIN: { + case LogicalOperatorType::LOGICAL_DELIM_JOIN: { auto &join = op.Cast(); join.join_type = InverseJoinType(join.join_type); for (auto &cond : join.conditions) { @@ -242,8 +241,7 @@ void BuildProbeSideOptimizer::VisitOperator(LogicalOperator &op) { } break; } - case LogicalOperatorType::LOGICAL_ANY_JOIN: - case LogicalOperatorType::LOGICAL_ASOF_JOIN: { + case LogicalOperatorType::LOGICAL_ANY_JOIN: { auto &join = op.Cast(); // We do not yet support the RIGHT_SEMI or RIGHT_ANTI join types for these, so don't try to flip switch (join.join_type) { diff --git a/src/duckdb/src/optimizer/filter_combiner.cpp b/src/duckdb/src/optimizer/filter_combiner.cpp index 2b360c9c6..a72354d7d 100644 --- a/src/duckdb/src/optimizer/filter_combiner.cpp +++ b/src/duckdb/src/optimizer/filter_combiner.cpp @@ -705,8 +705,26 @@ TableFilterSet FilterCombiner::GenerateTableScanFilters(const vector(comparison_type, const_val->value); - conj_filter->child_filters.push_back(std::move(const_filter)); + if (const_val->value.IsNull()) { + switch (comparison_type) { + case ExpressionType::COMPARE_DISTINCT_FROM: { + auto null_filter = make_uniq(); + conj_filter->child_filters.push_back(std::move(null_filter)); + break; + } + case ExpressionType::COMPARE_NOT_DISTINCT_FROM: { + auto null_filter = make_uniq(); + conj_filter->child_filters.push_back(std::move(null_filter)); + break; + } + // if any other comparison type (i.e EQUAL, NOT_EQUAL) do not push a table filter + default: + break; + } + } else { + auto const_filter = make_uniq(comparison_type, const_val->value); + conj_filter->child_filters.push_back(std::move(const_filter)); + } } if (column_id.IsValid()) { optional_filter->child_filter = std::move(conj_filter); @@ -716,8 +734,6 @@ TableFilterSet FilterCombiner::GenerateTableScanFilters(const vector Binder::Bind(TableFunctionRef &ref) { binder->can_contain_nulls = true; binder->alias = ref.alias.empty() ? "unnamed_query" : ref.alias; - auto query = binder->BindNode(*query_node); + unique_ptr query; + try { + query = binder->BindNode(*query_node); + } catch (std::exception &ex) { + ErrorData error(ex); + error.AddQueryLocation(ref); + error.Throw(); + } idx_t bind_index = query->GetRootIndex(); // string alias; diff --git a/src/duckdb/src/storage/checkpoint_manager.cpp b/src/duckdb/src/storage/checkpoint_manager.cpp index ca3295524..f28bdc454 100644 --- a/src/duckdb/src/storage/checkpoint_manager.cpp +++ b/src/duckdb/src/storage/checkpoint_manager.cpp @@ -450,7 +450,12 @@ void CheckpointReader::ReadIndex(CatalogTransaction transaction, Deserializer &d // look for the table in the catalog auto &schema = catalog.GetSchema(transaction, create_info->schema); - auto &table = schema.GetEntry(transaction, CatalogType::TABLE_ENTRY, info.table)->Cast(); + auto catalog_table = schema.GetEntry(transaction, CatalogType::TABLE_ENTRY, info.table); + if (!catalog_table) { + // See internal issue 3663. + throw IOException("corrupt database file - index entry without table entry"); + } + auto &table = catalog_table->Cast(); // we also need to make sure the index type is loaded // backwards compatibility: @@ -462,6 +467,7 @@ void CheckpointReader::ReadIndex(CatalogTransaction transaction, Deserializer &d // now we can look for the index in the catalog and assign the table info auto &index = schema.CreateIndex(transaction, info, table)->Cast(); auto &data_table = table.GetStorage(); + auto &table_info = data_table.GetDataTableInfo(); IndexStorageInfo index_storage_info; if (root_block_pointer.IsValid()) { @@ -471,7 +477,7 @@ void CheckpointReader::ReadIndex(CatalogTransaction transaction, Deserializer &d } else { // Read the matching index storage info. - for (auto const &elem : data_table.GetDataTableInfo()->GetIndexStorageInfo()) { + for (auto const &elem : table_info->GetIndexStorageInfo()) { if (elem.name == index.name) { index_storage_info = elem; break; @@ -479,12 +485,13 @@ void CheckpointReader::ReadIndex(CatalogTransaction transaction, Deserializer &d } } - D_ASSERT(index_storage_info.IsValid() && !index_storage_info.name.empty()); + D_ASSERT(index_storage_info.IsValid()); + D_ASSERT(!index_storage_info.name.empty()); // Create an unbound index and add it to the table. auto unbound_index = make_uniq(std::move(create_info), index_storage_info, TableIOManager::Get(data_table), data_table.db); - data_table.GetDataTableInfo()->GetIndexes().AddIndex(std::move(unbound_index)); + table_info->GetIndexes().AddIndex(std::move(unbound_index)); } //===--------------------------------------------------------------------===// diff --git a/src/duckdb/src/storage/compression/bitpacking.cpp b/src/duckdb/src/storage/compression/bitpacking.cpp index aa7f24871..af2e35c2d 100644 --- a/src/duckdb/src/storage/compression/bitpacking.cpp +++ b/src/duckdb/src/storage/compression/bitpacking.cpp @@ -377,18 +377,18 @@ idx_t BitpackingFinalAnalyze(AnalyzeState &state) { template ::type> struct BitpackingCompressState : public CompressionState { public: - explicit BitpackingCompressState(ColumnDataCheckpointer &checkpointer, const CompressionInfo &info) - : CompressionState(info), checkpointer(checkpointer), - function(checkpointer.GetCompressionFunction(CompressionType::COMPRESSION_BITPACKING)) { - CreateEmptySegment(checkpointer.GetRowGroup().start); + explicit BitpackingCompressState(ColumnDataCheckpointData &checkpoint_data, const CompressionInfo &info) + : CompressionState(info), checkpoint_data(checkpoint_data), + function(checkpoint_data.GetCompressionFunction(CompressionType::COMPRESSION_BITPACKING)) { + CreateEmptySegment(checkpoint_data.GetRowGroup().start); state.data_ptr = reinterpret_cast(this); - auto &config = DBConfig::GetConfig(checkpointer.GetDatabase()); + auto &config = DBConfig::GetConfig(checkpoint_data.GetDatabase()); state.mode = config.options.force_bitpacking_mode; } - ColumnDataCheckpointer &checkpointer; + ColumnDataCheckpointData &checkpoint_data; CompressionFunction &function; unique_ptr current_segment; BufferHandle handle; @@ -495,8 +495,8 @@ struct BitpackingCompressState : public CompressionState { } void CreateEmptySegment(idx_t row_start) { - auto &db = checkpointer.GetDatabase(); - auto &type = checkpointer.GetType(); + auto &db = checkpoint_data.GetDatabase(); + auto &type = checkpoint_data.GetType(); auto compressed_segment = ColumnSegment::CreateTransientSegment(db, function, type, row_start, info.GetBlockSize(), info.GetBlockSize()); @@ -528,7 +528,7 @@ struct BitpackingCompressState : public CompressionState { } void FlushSegment() { - auto &state = checkpointer.GetCheckpointState(); + auto &state = checkpoint_data.GetCheckpointState(); auto base_ptr = handle.Ptr(); // Compact the segment by moving the metadata next to the data. @@ -563,9 +563,9 @@ struct BitpackingCompressState : public CompressionState { }; template -unique_ptr BitpackingInitCompression(ColumnDataCheckpointer &checkpointer, +unique_ptr BitpackingInitCompression(ColumnDataCheckpointData &checkpoint_data, unique_ptr state) { - return make_uniq>(checkpointer, state->info); + return make_uniq>(checkpoint_data, state->info); } template diff --git a/src/duckdb/src/storage/compression/dictionary/compression.cpp b/src/duckdb/src/storage/compression/dictionary/compression.cpp index 0b9a47e98..064697fc7 100644 --- a/src/duckdb/src/storage/compression/dictionary/compression.cpp +++ b/src/duckdb/src/storage/compression/dictionary/compression.cpp @@ -3,17 +3,17 @@ namespace duckdb { -DictionaryCompressionCompressState::DictionaryCompressionCompressState(ColumnDataCheckpointer &checkpointer_p, +DictionaryCompressionCompressState::DictionaryCompressionCompressState(ColumnDataCheckpointData &checkpoint_data_p, const CompressionInfo &info) - : DictionaryCompressionState(info), checkpointer(checkpointer_p), - function(checkpointer.GetCompressionFunction(CompressionType::COMPRESSION_DICTIONARY)), - heap(BufferAllocator::Get(checkpointer.GetDatabase())) { - CreateEmptySegment(checkpointer.GetRowGroup().start); + : DictionaryCompressionState(info), checkpoint_data(checkpoint_data_p), + function(checkpoint_data.GetCompressionFunction(CompressionType::COMPRESSION_DICTIONARY)), + heap(BufferAllocator::Get(checkpoint_data.GetDatabase())) { + CreateEmptySegment(checkpoint_data.GetRowGroup().start); } void DictionaryCompressionCompressState::CreateEmptySegment(idx_t row_start) { - auto &db = checkpointer.GetDatabase(); - auto &type = checkpointer.GetType(); + auto &db = checkpoint_data.GetDatabase(); + auto &type = checkpoint_data.GetType(); auto compressed_segment = ColumnSegment::CreateTransientSegment(db, function, type, row_start, info.GetBlockSize(), info.GetBlockSize()); @@ -31,7 +31,7 @@ void DictionaryCompressionCompressState::CreateEmptySegment(idx_t row_start) { next_width = 0; // Reset the pointers into the current segment. - auto &buffer_manager = BufferManager::GetBufferManager(checkpointer.GetDatabase()); + auto &buffer_manager = BufferManager::GetBufferManager(checkpoint_data.GetDatabase()); current_handle = buffer_manager.Pin(current_segment->block); current_dictionary = DictionaryCompression::GetDictionary(*current_segment, current_handle); current_end_ptr = current_handle.Ptr() + current_dictionary.end; @@ -105,7 +105,7 @@ void DictionaryCompressionCompressState::Flush(bool final) { auto next_start = current_segment->start + current_segment->count; auto segment_size = Finalize(); - auto &state = checkpointer.GetCheckpointState(); + auto &state = checkpoint_data.GetCheckpointState(); state.FlushSegment(std::move(current_segment), std::move(current_handle), segment_size); if (!final) { @@ -114,7 +114,7 @@ void DictionaryCompressionCompressState::Flush(bool final) { } idx_t DictionaryCompressionCompressState::Finalize() { - auto &buffer_manager = BufferManager::GetBufferManager(checkpointer.GetDatabase()); + auto &buffer_manager = BufferManager::GetBufferManager(checkpoint_data.GetDatabase()); auto handle = buffer_manager.Pin(current_segment->block); D_ASSERT(current_dictionary.end == info.GetBlockSize()); diff --git a/src/duckdb/src/storage/compression/dictionary_compression.cpp b/src/duckdb/src/storage/compression/dictionary_compression.cpp index 1ea1bb326..6f6b4beed 100644 --- a/src/duckdb/src/storage/compression/dictionary_compression.cpp +++ b/src/duckdb/src/storage/compression/dictionary_compression.cpp @@ -52,7 +52,7 @@ struct DictionaryCompressionStorage { static bool StringAnalyze(AnalyzeState &state_p, Vector &input, idx_t count); static idx_t StringFinalAnalyze(AnalyzeState &state_p); - static unique_ptr InitCompression(ColumnDataCheckpointer &checkpointer, + static unique_ptr InitCompression(ColumnDataCheckpointData &checkpoint_data, unique_ptr state); static void Compress(CompressionState &state_p, Vector &scan_vector, idx_t count); static void FinalizeCompress(CompressionState &state_p); @@ -94,9 +94,9 @@ idx_t DictionaryCompressionStorage::StringFinalAnalyze(AnalyzeState &state_p) { //===--------------------------------------------------------------------===// // Compress //===--------------------------------------------------------------------===// -unique_ptr DictionaryCompressionStorage::InitCompression(ColumnDataCheckpointer &checkpointer, +unique_ptr DictionaryCompressionStorage::InitCompression(ColumnDataCheckpointData &checkpoint_data, unique_ptr state) { - return make_uniq(checkpointer, state->info); + return make_uniq(checkpoint_data, state->info); } void DictionaryCompressionStorage::Compress(CompressionState &state_p, Vector &scan_vector, idx_t count) { diff --git a/src/duckdb/src/storage/compression/fixed_size_uncompressed.cpp b/src/duckdb/src/storage/compression/fixed_size_uncompressed.cpp index f694a13f8..3215f1b8f 100644 --- a/src/duckdb/src/storage/compression/fixed_size_uncompressed.cpp +++ b/src/duckdb/src/storage/compression/fixed_size_uncompressed.cpp @@ -43,7 +43,7 @@ idx_t FixedSizeFinalAnalyze(AnalyzeState &state_p) { //===--------------------------------------------------------------------===// struct UncompressedCompressState : public CompressionState { public: - UncompressedCompressState(ColumnDataCheckpointer &checkpointer, const CompressionInfo &info); + UncompressedCompressState(ColumnDataCheckpointData &checkpoint_data, const CompressionInfo &info); public: virtual void CreateEmptySegment(idx_t row_start); @@ -51,35 +51,36 @@ struct UncompressedCompressState : public CompressionState { void Finalize(idx_t segment_size); public: - ColumnDataCheckpointer &checkpointer; + ColumnDataCheckpointData &checkpoint_data; CompressionFunction &function; unique_ptr current_segment; ColumnAppendState append_state; }; -UncompressedCompressState::UncompressedCompressState(ColumnDataCheckpointer &checkpointer, const CompressionInfo &info) - : CompressionState(info), checkpointer(checkpointer), - function(checkpointer.GetCompressionFunction(CompressionType::COMPRESSION_UNCOMPRESSED)) { - UncompressedCompressState::CreateEmptySegment(checkpointer.GetRowGroup().start); +UncompressedCompressState::UncompressedCompressState(ColumnDataCheckpointData &checkpoint_data, + const CompressionInfo &info) + : CompressionState(info), checkpoint_data(checkpoint_data), + function(checkpoint_data.GetCompressionFunction(CompressionType::COMPRESSION_UNCOMPRESSED)) { + UncompressedCompressState::CreateEmptySegment(checkpoint_data.GetRowGroup().start); } void UncompressedCompressState::CreateEmptySegment(idx_t row_start) { - auto &db = checkpointer.GetDatabase(); - auto &type = checkpointer.GetType(); + auto &db = checkpoint_data.GetDatabase(); + auto &type = checkpoint_data.GetType(); auto compressed_segment = ColumnSegment::CreateTransientSegment(db, function, type, row_start, info.GetBlockSize(), info.GetBlockSize()); if (type.InternalType() == PhysicalType::VARCHAR) { auto &state = compressed_segment->GetSegmentState()->Cast(); state.overflow_writer = - make_uniq(checkpointer.GetCheckpointState().GetPartialBlockManager()); + make_uniq(checkpoint_data.GetCheckpointState().GetPartialBlockManager()); } current_segment = std::move(compressed_segment); current_segment->InitializeAppend(append_state); } void UncompressedCompressState::FlushSegment(idx_t segment_size) { - auto &state = checkpointer.GetCheckpointState(); + auto &state = checkpoint_data.GetCheckpointState(); if (current_segment->type.InternalType() == PhysicalType::VARCHAR) { auto &segment_state = current_segment->GetSegmentState()->Cast(); segment_state.overflow_writer->Flush(); @@ -96,9 +97,9 @@ void UncompressedCompressState::Finalize(idx_t segment_size) { current_segment.reset(); } -unique_ptr UncompressedFunctions::InitCompression(ColumnDataCheckpointer &checkpointer, +unique_ptr UncompressedFunctions::InitCompression(ColumnDataCheckpointData &checkpoint_data, unique_ptr state) { - return make_uniq(checkpointer, state->info); + return make_uniq(checkpoint_data, state->info); } void UncompressedFunctions::Compress(CompressionState &state_p, Vector &data, idx_t count) { diff --git a/src/duckdb/src/storage/compression/fsst.cpp b/src/duckdb/src/storage/compression/fsst.cpp index 6d0bb9b3d..bc5c52228 100644 --- a/src/duckdb/src/storage/compression/fsst.cpp +++ b/src/duckdb/src/storage/compression/fsst.cpp @@ -43,7 +43,7 @@ struct FSSTStorage { static bool StringAnalyze(AnalyzeState &state_p, Vector &input, idx_t count); static idx_t StringFinalAnalyze(AnalyzeState &state_p); - static unique_ptr InitCompression(ColumnDataCheckpointer &checkpointer, + static unique_ptr InitCompression(ColumnDataCheckpointData &checkpoint_data, unique_ptr analyze_state_p); static void Compress(CompressionState &state_p, Vector &scan_vector, idx_t count); static void FinalizeCompress(CompressionState &state_p); @@ -208,10 +208,10 @@ idx_t FSSTStorage::StringFinalAnalyze(AnalyzeState &state_p) { class FSSTCompressionState : public CompressionState { public: - FSSTCompressionState(ColumnDataCheckpointer &checkpointer, const CompressionInfo &info) - : CompressionState(info), checkpointer(checkpointer), - function(checkpointer.GetCompressionFunction(CompressionType::COMPRESSION_FSST)) { - CreateEmptySegment(checkpointer.GetRowGroup().start); + FSSTCompressionState(ColumnDataCheckpointData &checkpoint_data, const CompressionInfo &info) + : CompressionState(info), checkpoint_data(checkpoint_data), + function(checkpoint_data.GetCompressionFunction(CompressionType::COMPRESSION_FSST)) { + CreateEmptySegment(checkpoint_data.GetRowGroup().start); } ~FSSTCompressionState() override { @@ -234,8 +234,8 @@ class FSSTCompressionState : public CompressionState { } void CreateEmptySegment(idx_t row_start) { - auto &db = checkpointer.GetDatabase(); - auto &type = checkpointer.GetType(); + auto &db = checkpoint_data.GetDatabase(); + auto &type = checkpoint_data.GetType(); auto compressed_segment = ColumnSegment::CreateTransientSegment(db, function, type, row_start, info.GetBlockSize(), info.GetBlockSize()); @@ -318,7 +318,7 @@ class FSSTCompressionState : public CompressionState { auto next_start = current_segment->start + current_segment->count; auto segment_size = Finalize(); - auto &state = checkpointer.GetCheckpointState(); + auto &state = checkpoint_data.GetCheckpointState(); state.FlushSegment(std::move(current_segment), std::move(current_handle), segment_size); if (!final) { @@ -382,7 +382,7 @@ class FSSTCompressionState : public CompressionState { return total_size; } - ColumnDataCheckpointer &checkpointer; + ColumnDataCheckpointData &checkpoint_data; CompressionFunction &function; // State regarding current segment @@ -403,10 +403,10 @@ class FSSTCompressionState : public CompressionState { size_t fsst_serialized_symbol_table_size = sizeof(duckdb_fsst_decoder_t); }; -unique_ptr FSSTStorage::InitCompression(ColumnDataCheckpointer &checkpointer, +unique_ptr FSSTStorage::InitCompression(ColumnDataCheckpointData &checkpoint_data, unique_ptr analyze_state_p) { auto &analyze_state = analyze_state_p->Cast(); - auto compression_state = make_uniq(checkpointer, analyze_state.info); + auto compression_state = make_uniq(checkpoint_data, analyze_state.info); if (analyze_state.fsst_encoder == nullptr) { throw InternalException("No encoder found during FSST compression"); diff --git a/src/duckdb/src/storage/compression/rle.cpp b/src/duckdb/src/storage/compression/rle.cpp index d453f9b8d..0144ff829 100644 --- a/src/duckdb/src/storage/compression/rle.cpp +++ b/src/duckdb/src/storage/compression/rle.cpp @@ -137,18 +137,18 @@ struct RLECompressState : public CompressionState { return (info.GetBlockSize() - RLEConstants::RLE_HEADER_SIZE) / entry_size; } - RLECompressState(ColumnDataCheckpointer &checkpointer_p, const CompressionInfo &info) - : CompressionState(info), checkpointer(checkpointer_p), - function(checkpointer.GetCompressionFunction(CompressionType::COMPRESSION_RLE)) { - CreateEmptySegment(checkpointer.GetRowGroup().start); + RLECompressState(ColumnDataCheckpointData &checkpoint_data_p, const CompressionInfo &info) + : CompressionState(info), checkpoint_data(checkpoint_data_p), + function(checkpoint_data.GetCompressionFunction(CompressionType::COMPRESSION_RLE)) { + CreateEmptySegment(checkpoint_data.GetRowGroup().start); state.dataptr = (void *)this; max_rle_count = MaxRLECount(); } void CreateEmptySegment(idx_t row_start) { - auto &db = checkpointer.GetDatabase(); - auto &type = checkpointer.GetType(); + auto &db = checkpoint_data.GetDatabase(); + auto &type = checkpoint_data.GetType(); auto column_segment = ColumnSegment::CreateTransientSegment(db, function, type, row_start, info.GetBlockSize(), info.GetBlockSize()); @@ -203,7 +203,7 @@ struct RLECompressState : public CompressionState { Store(minimal_rle_offset, data_ptr); handle.Destroy(); - auto &state = checkpointer.GetCheckpointState(); + auto &state = checkpoint_data.GetCheckpointState(); state.FlushSegment(std::move(current_segment), std::move(handle), total_segment_size); } @@ -214,7 +214,7 @@ struct RLECompressState : public CompressionState { current_segment.reset(); } - ColumnDataCheckpointer &checkpointer; + ColumnDataCheckpointData &checkpoint_data; CompressionFunction &function; unique_ptr current_segment; BufferHandle handle; @@ -225,8 +225,9 @@ struct RLECompressState : public CompressionState { }; template -unique_ptr RLEInitCompression(ColumnDataCheckpointer &checkpointer, unique_ptr state) { - return make_uniq>(checkpointer, state->info); +unique_ptr RLEInitCompression(ColumnDataCheckpointData &checkpoint_data, + unique_ptr state) { + return make_uniq>(checkpoint_data, state->info); } template diff --git a/src/duckdb/src/storage/compression/roaring/common.cpp b/src/duckdb/src/storage/compression/roaring/common.cpp index d680a4d02..e5dad7503 100644 --- a/src/duckdb/src/storage/compression/roaring/common.cpp +++ b/src/duckdb/src/storage/compression/roaring/common.cpp @@ -188,9 +188,9 @@ idx_t RoaringFinalAnalyze(AnalyzeState &state) { return LossyNumericCast((double)roaring_state.total_size * ROARING_COMPRESS_PENALTY); } -unique_ptr RoaringInitCompression(ColumnDataCheckpointer &checkpointer, +unique_ptr RoaringInitCompression(ColumnDataCheckpointData &checkpoint_data, unique_ptr state) { - return make_uniq(checkpointer, std::move(state)); + return make_uniq(checkpoint_data, std::move(state)); } void RoaringCompress(CompressionState &state_p, Vector &scan_vector, idx_t count) { diff --git a/src/duckdb/src/storage/compression/roaring/compress.cpp b/src/duckdb/src/storage/compression/roaring/compress.cpp index 7de695b96..77463d9e2 100644 --- a/src/duckdb/src/storage/compression/roaring/compress.cpp +++ b/src/duckdb/src/storage/compression/roaring/compress.cpp @@ -193,13 +193,13 @@ void ContainerCompressionState::Reset() { //===--------------------------------------------------------------------===// // Compress //===--------------------------------------------------------------------===// -RoaringCompressState::RoaringCompressState(ColumnDataCheckpointer &checkpointer, +RoaringCompressState::RoaringCompressState(ColumnDataCheckpointData &checkpoint_data, unique_ptr analyze_state_p) : CompressionState(analyze_state_p->info), owned_analyze_state(std::move(analyze_state_p)), analyze_state(owned_analyze_state->Cast()), container_state(), - container_metadata(analyze_state.container_metadata), checkpointer(checkpointer), - function(checkpointer.GetCompressionFunction(CompressionType::COMPRESSION_ROARING)) { - CreateEmptySegment(checkpointer.GetRowGroup().start); + container_metadata(analyze_state.container_metadata), checkpoint_data(checkpoint_data), + function(checkpoint_data.GetCompressionFunction(CompressionType::COMPRESSION_ROARING)) { + CreateEmptySegment(checkpoint_data.GetRowGroup().start); total_count = 0; InitializeContainer(); } @@ -276,8 +276,8 @@ void RoaringCompressState::InitializeContainer() { } void RoaringCompressState::CreateEmptySegment(idx_t row_start) { - auto &db = checkpointer.GetDatabase(); - auto &type = checkpointer.GetType(); + auto &db = checkpoint_data.GetDatabase(); + auto &type = checkpoint_data.GetType(); auto compressed_segment = ColumnSegment::CreateTransientSegment(db, function, type, row_start, info.GetBlockSize(), info.GetBlockSize()); @@ -291,7 +291,7 @@ void RoaringCompressState::CreateEmptySegment(idx_t row_start) { } void RoaringCompressState::FlushSegment() { - auto &state = checkpointer.GetCheckpointState(); + auto &state = checkpoint_data.GetCheckpointState(); auto base_ptr = handle.Ptr(); // +======================================+ // |x|ddddddddddddddd||mmm| | diff --git a/src/duckdb/src/storage/compression/zstd.cpp b/src/duckdb/src/storage/compression/zstd.cpp index 945cd644f..6552f0dc8 100644 --- a/src/duckdb/src/storage/compression/zstd.cpp +++ b/src/duckdb/src/storage/compression/zstd.cpp @@ -76,7 +76,7 @@ struct ZSTDStorage { static bool StringAnalyze(AnalyzeState &state_p, Vector &input, idx_t count); static idx_t StringFinalAnalyze(AnalyzeState &state_p); - static unique_ptr InitCompression(ColumnDataCheckpointer &checkpointer, + static unique_ptr InitCompression(ColumnDataCheckpointData &checkpoint_data, unique_ptr analyze_state_p); static void Compress(CompressionState &state_p, Vector &scan_vector, idx_t count); static void FinalizeCompress(CompressionState &state_p); @@ -218,10 +218,12 @@ idx_t ZSTDStorage::StringFinalAnalyze(AnalyzeState &state_p) { class ZSTDCompressionState : public CompressionState { public: - explicit ZSTDCompressionState(ColumnDataCheckpointer &checkpointer, unique_ptr &&analyze_state_p) + explicit ZSTDCompressionState(ColumnDataCheckpointData &checkpoint_data, + unique_ptr &&analyze_state_p) : CompressionState(analyze_state_p->info), analyze_state(std::move(analyze_state_p)), - checkpointer(checkpointer), partial_block_manager(checkpointer.GetCheckpointState().GetPartialBlockManager()), - function(checkpointer.GetCompressionFunction(CompressionType::COMPRESSION_ZSTD)) { + checkpoint_data(checkpoint_data), + partial_block_manager(checkpoint_data.GetCheckpointState().GetPartialBlockManager()), + function(checkpoint_data.GetCompressionFunction(CompressionType::COMPRESSION_ZSTD)) { total_vector_count = GetVectorCount(analyze_state->count); total_segment_count = analyze_state->segment_count; @@ -303,7 +305,7 @@ class ZSTDCompressionState : public CompressionState { row_start = segment->start + segment->count; FlushSegment(); } else { - row_start = checkpointer.GetRowGroup().start; + row_start = checkpoint_data.GetRowGroup().start; } CreateEmptySegment(row_start); @@ -517,18 +519,18 @@ class ZSTDCompressionState : public CompressionState { } void CreateEmptySegment(idx_t row_start) { - auto &db = checkpointer.GetDatabase(); - auto &type = checkpointer.GetType(); + auto &db = checkpoint_data.GetDatabase(); + auto &type = checkpoint_data.GetType(); auto compressed_segment = ColumnSegment::CreateTransientSegment(db, function, type, row_start, info.GetBlockSize(), info.GetBlockSize()); segment = std::move(compressed_segment); - auto &buffer_manager = BufferManager::GetBufferManager(checkpointer.GetDatabase()); + auto &buffer_manager = BufferManager::GetBufferManager(checkpoint_data.GetDatabase()); segment_handle = buffer_manager.Pin(segment->block); } void FlushSegment() { - auto &state = checkpointer.GetCheckpointState(); + auto &state = checkpoint_data.GetCheckpointState(); idx_t segment_block_size; if (current_buffer.get() == &segment_handle) { @@ -555,7 +557,7 @@ class ZSTDCompressionState : public CompressionState { public: unique_ptr analyze_state; - ColumnDataCheckpointer &checkpointer; + ColumnDataCheckpointData &checkpoint_data; PartialBlockManager &partial_block_manager; CompressionFunction &function; @@ -611,9 +613,9 @@ class ZSTDCompressionState : public CompressionState { idx_t vector_size; }; -unique_ptr ZSTDStorage::InitCompression(ColumnDataCheckpointer &checkpointer, +unique_ptr ZSTDStorage::InitCompression(ColumnDataCheckpointData &checkpoint_data, unique_ptr analyze_state_p) { - return make_uniq(checkpointer, + return make_uniq(checkpoint_data, unique_ptr_cast(std::move(analyze_state_p))); } diff --git a/src/duckdb/src/storage/table/column_data.cpp b/src/duckdb/src/storage/table/column_data.cpp index 5b4b1cafa..53e7c5459 100644 --- a/src/duckdb/src/storage/table/column_data.cpp +++ b/src/duckdb/src/storage/table/column_data.cpp @@ -620,26 +620,16 @@ unique_ptr ColumnData::Checkpoint(RowGroup &row_group, Co auto checkpoint_state = CreateCheckpointState(row_group, checkpoint_info.info.manager); checkpoint_state->global_stats = BaseStatistics::CreateEmpty(type).ToUnique(); - auto l = data.Lock(); - auto &nodes = data.ReferenceSegments(l); + auto &nodes = data.ReferenceSegments(); if (nodes.empty()) { // empty table: flush the empty list return checkpoint_state; } - ColumnDataCheckpointer checkpointer(*this, row_group, *checkpoint_state, checkpoint_info); - checkpointer.Checkpoint(nodes); - checkpointer.FinalizeCheckpoint(data.MoveSegments(l)); - - // reset the compression function - compression.reset(); - // replace the old tree with the new one - auto new_segments = checkpoint_state->new_tree.MoveSegments(); - for (auto &new_segment : new_segments) { - AppendSegment(l, std::move(new_segment.node)); - } - ClearUpdates(); - + vector> states {*checkpoint_state}; + ColumnDataCheckpointer checkpointer(states, GetDatabase(), row_group, checkpoint_info); + checkpointer.Checkpoint(); + checkpointer.FinalizeCheckpoint(); return checkpoint_state; } diff --git a/src/duckdb/src/storage/table/column_data_checkpointer.cpp b/src/duckdb/src/storage/table/column_data_checkpointer.cpp index 2a7f0e957..13658077d 100644 --- a/src/duckdb/src/storage/table/column_data_checkpointer.cpp +++ b/src/duckdb/src/storage/table/column_data_checkpointer.cpp @@ -7,43 +7,74 @@ namespace duckdb { -ColumnDataCheckpointer::ColumnDataCheckpointer(ColumnData &col_data_p, RowGroup &row_group_p, - ColumnCheckpointState &state_p, ColumnCheckpointInfo &checkpoint_info_p) - : col_data(col_data_p), row_group(row_group_p), state(state_p), - is_validity(GetType().id() == LogicalTypeId::VALIDITY), - intermediate(is_validity ? LogicalType::BOOLEAN : GetType(), true, is_validity), - checkpoint_info(checkpoint_info_p) { - - auto &config = DBConfig::GetConfig(GetDatabase()); - auto functions = config.GetCompressionFunctions(GetType().InternalType()); - for (auto &func : functions) { - compression_functions.push_back(&func.get()); - } +//! ColumnDataCheckpointData + +CompressionFunction &ColumnDataCheckpointData::GetCompressionFunction(CompressionType compression_type) { + auto &db = col_data->GetDatabase(); + auto &column_type = col_data->type; + auto &config = DBConfig::GetConfig(db); + return *config.GetCompressionFunction(compression_type, column_type.InternalType()); +} + +DatabaseInstance &ColumnDataCheckpointData::GetDatabase() { + return col_data->GetDatabase(); } -DatabaseInstance &ColumnDataCheckpointer::GetDatabase() { - return col_data.GetDatabase(); +const LogicalType &ColumnDataCheckpointData::GetType() const { + return col_data->type; } -const LogicalType &ColumnDataCheckpointer::GetType() const { - return col_data.type; +ColumnData &ColumnDataCheckpointData::GetColumnData() { + return *col_data; } -ColumnData &ColumnDataCheckpointer::GetColumnData() { - return col_data; +RowGroup &ColumnDataCheckpointData::GetRowGroup() { + return *row_group; } -RowGroup &ColumnDataCheckpointer::GetRowGroup() { - return row_group; +ColumnCheckpointState &ColumnDataCheckpointData::GetCheckpointState() { + return *checkpoint_state; } -ColumnCheckpointState &ColumnDataCheckpointer::GetCheckpointState() { - return state; +//! ColumnDataCheckpointer + +static Vector CreateIntermediateVector(vector> &states) { + D_ASSERT(!states.empty()); + + auto &first_state = states[0]; + auto &col_data = first_state.get().column_data; + auto &type = col_data.type; + if (type.id() == LogicalTypeId::VALIDITY) { + return Vector(LogicalType::BOOLEAN, true, /* initialize_to_zero = */ true); + } + return Vector(type, true, false); +} + +ColumnDataCheckpointer::ColumnDataCheckpointer(vector> &checkpoint_states, + DatabaseInstance &db, RowGroup &row_group, + ColumnCheckpointInfo &checkpoint_info) + : checkpoint_states(checkpoint_states), db(db), row_group(row_group), + intermediate(CreateIntermediateVector(checkpoint_states)), checkpoint_info(checkpoint_info) { + + auto &config = DBConfig::GetConfig(db); + compression_functions.resize(checkpoint_states.size()); + for (idx_t i = 0; i < checkpoint_states.size(); i++) { + auto &col_data = checkpoint_states[i].get().column_data; + auto to_add = config.GetCompressionFunctions(col_data.type.InternalType()); + auto &functions = compression_functions[i]; + for (auto &func : to_add) { + functions.push_back(&func.get()); + } + } } -void ColumnDataCheckpointer::ScanSegments(const column_segment_vector_t &nodes, - const std::function &callback) { +void ColumnDataCheckpointer::ScanSegments(const std::function &callback) { Vector scan_vector(intermediate.GetType(), nullptr); + auto &first_state = checkpoint_states[0]; + auto &col_data = first_state.get().column_data; + auto &nodes = col_data.data.ReferenceSegments(); + + // TODO: scan all the nodes from all segments, no need for CheckpointScan to virtualize this I think.. for (idx_t segment_idx = 0; segment_idx < nodes.size(); segment_idx++) { auto &segment = *nodes[segment_idx].node; ColumnScanState scan_state; @@ -57,7 +88,6 @@ void ColumnDataCheckpointer::ScanSegments(const column_segment_vector_t &nodes, scan_state.row_index = segment.start + base_row_index; col_data.CheckpointScan(segment, scan_state, row_group.start, count, scan_vector); - callback(scan_vector, count); } } @@ -80,132 +110,219 @@ CompressionType ForceCompression(vector> &comp break; } } - if (found) { - // the force_compression method is available - // clear all other compression methods - // except the uncompressed method, so we can fall back on that - for (idx_t i = 0; i < compression_functions.size(); i++) { - auto &compression_function = *compression_functions[i]; - if (compression_function.type == CompressionType::COMPRESSION_UNCOMPRESSED) { + if (!found) { + return CompressionType::COMPRESSION_AUTO; + } + // the force_compression method is available + // clear all other compression methods + // except the uncompressed method, so we can fall back on that + for (idx_t i = 0; i < compression_functions.size(); i++) { + auto &compression_function = *compression_functions[i]; + if (compression_function.type == CompressionType::COMPRESSION_UNCOMPRESSED) { + continue; + } + if (compression_function.type != compression_type) { + compression_functions[i] = nullptr; + } + } + return compression_type; +} + +void ColumnDataCheckpointer::InitAnalyze() { + analyze_states.resize(checkpoint_states.size()); + for (idx_t i = 0; i < checkpoint_states.size(); i++) { + if (!has_changes[i]) { + continue; + } + + auto &functions = compression_functions[i]; + auto &states = analyze_states[i]; + auto &checkpoint_state = checkpoint_states[i]; + auto &coldata = checkpoint_state.get().column_data; + states.resize(functions.size()); + for (idx_t j = 0; j < functions.size(); j++) { + auto &func = functions[j]; + if (!func) { continue; } - if (compression_function.type != compression_type) { - compression_functions[i] = nullptr; - } + states[j] = func->init_analyze(coldata, coldata.type.InternalType()); } } - return found ? compression_type : CompressionType::COMPRESSION_AUTO; } -unique_ptr ColumnDataCheckpointer::DetectBestCompressionMethod(const column_segment_vector_t &nodes, - idx_t &compression_idx) { +vector ColumnDataCheckpointer::DetectBestCompressionMethod() { D_ASSERT(!compression_functions.empty()); - auto &config = DBConfig::GetConfig(GetDatabase()); - CompressionType forced_method = CompressionType::COMPRESSION_AUTO; + auto &config = DBConfig::GetConfig(db); + vector forced_methods(checkpoint_states.size(), CompressionType::COMPRESSION_AUTO); auto compression_type = checkpoint_info.GetCompressionType(); - if (compression_type != CompressionType::COMPRESSION_AUTO) { - forced_method = ForceCompression(compression_functions, compression_type); - } - if (compression_type == CompressionType::COMPRESSION_AUTO && - config.options.force_compression != CompressionType::COMPRESSION_AUTO) { - forced_method = ForceCompression(compression_functions, config.options.force_compression); - } - // set up the analyze states for each compression method - vector> analyze_states; - analyze_states.reserve(compression_functions.size()); - for (idx_t i = 0; i < compression_functions.size(); i++) { - if (!compression_functions[i]) { - analyze_states.push_back(nullptr); - continue; + for (idx_t i = 0; i < checkpoint_states.size(); i++) { + auto &functions = compression_functions[i]; + if (compression_type != CompressionType::COMPRESSION_AUTO) { + forced_methods[i] = ForceCompression(functions, compression_type); + } + if (compression_type == CompressionType::COMPRESSION_AUTO && + config.options.force_compression != CompressionType::COMPRESSION_AUTO) { + forced_methods[i] = ForceCompression(functions, config.options.force_compression); } - analyze_states.push_back(compression_functions[i]->init_analyze(col_data, col_data.type.InternalType())); } + InitAnalyze(); + // scan over all the segments and run the analyze step - ScanSegments(nodes, [&](Vector &scan_vector, idx_t count) { - for (idx_t i = 0; i < compression_functions.size(); i++) { - if (!compression_functions[i]) { + ScanSegments([&](Vector &scan_vector, idx_t count) { + for (idx_t i = 0; i < checkpoint_states.size(); i++) { + if (!has_changes[i]) { continue; } - bool success = false; - if (analyze_states[i]) { - success = compression_functions[i]->analyze(*analyze_states[i], scan_vector, count); - } - if (!success) { - // could not use this compression function on this data set - // erase it - compression_functions[i] = nullptr; - analyze_states[i].reset(); + + auto &functions = compression_functions[i]; + auto &states = analyze_states[i]; + for (idx_t j = 0; j < functions.size(); j++) { + auto &state = states[j]; + auto &func = functions[j]; + + if (!state) { + continue; + } + if (!func->analyze(*state, scan_vector, count)) { + state = nullptr; + func = nullptr; + } } } }); - // now that we have passed over all the data, we need to figure out the best method - // we do this using the final_analyze method - unique_ptr state; - compression_idx = DConstants::INVALID_INDEX; - idx_t best_score = NumericLimits::Maximum(); - for (idx_t i = 0; i < compression_functions.size(); i++) { - if (!compression_functions[i]) { - continue; - } - if (!analyze_states[i]) { - continue; - } - //! Check if the method type is the forced method (if forced is used) - bool forced_method_found = compression_functions[i]->type == forced_method; - auto score = compression_functions[i]->final_analyze(*analyze_states[i]); + vector result; + result.resize(checkpoint_states.size()); - //! The finalize method can return this value from final_analyze to indicate it should not be used. - if (score == DConstants::INVALID_INDEX) { + for (idx_t i = 0; i < checkpoint_states.size(); i++) { + if (!has_changes[i]) { continue; } + auto &functions = compression_functions[i]; + auto &states = analyze_states[i]; + auto &forced_method = forced_methods[i]; + + unique_ptr chosen_state; + idx_t best_score = NumericLimits::Maximum(); + idx_t compression_idx = DConstants::INVALID_INDEX; - if (score < best_score || forced_method_found) { - compression_idx = i; - best_score = score; - state = std::move(analyze_states[i]); + D_ASSERT(functions.size() == states.size()); + for (idx_t j = 0; j < functions.size(); j++) { + auto &function = functions[j]; + auto &state = states[j]; + + if (!state) { + continue; + } + + //! Check if the method type is the forced method (if forced is used) + bool forced_method_found = function->type == forced_method; + // now that we have passed over all the data, we need to figure out the best method + // we do this using the final_analyze method + auto score = function->final_analyze(*state); + + //! The finalize method can return this value from final_analyze to indicate it should not be used. + if (score == DConstants::INVALID_INDEX) { + continue; + } + + if (score < best_score || forced_method_found) { + compression_idx = j; + best_score = score; + chosen_state = std::move(state); + } + //! If we have found the forced method, we're done + if (forced_method_found) { + break; + } } - //! If we have found the forced method, we're done - if (forced_method_found) { - break; + + if (!chosen_state) { + auto &checkpoint_state = checkpoint_states[i]; + auto &col_data = checkpoint_state.get().column_data; + throw FatalException("No suitable compression/storage method found to store column of type %s", + col_data.type.ToString()); } + D_ASSERT(compression_idx != DConstants::INVALID_INDEX); + result[i] = CheckpointAnalyzeResult(std::move(chosen_state), *functions[compression_idx]); } - return state; + return result; } -void ColumnDataCheckpointer::WriteToDisk(const column_segment_vector_t &nodes) { - // there were changes or transient segments - // we need to rewrite the column segments to disk - +void ColumnDataCheckpointer::DropSegments() { // first we check the current segments // if there are any persistent segments, we will mark their old block ids as modified // since the segments will be rewritten their old on disk data is no longer required - for (idx_t segment_idx = 0; segment_idx < nodes.size(); segment_idx++) { - auto segment = nodes[segment_idx].node.get(); - segment->CommitDropSegment(); + + for (idx_t i = 0; i < checkpoint_states.size(); i++) { + if (!has_changes[i]) { + continue; + } + + auto &state = checkpoint_states[i]; + auto &col_data = state.get().column_data; + auto &nodes = col_data.data.ReferenceSegments(); + + // Drop the segments, as we'll be replacing them with new ones, because there are changes + for (idx_t segment_idx = 0; segment_idx < nodes.size(); segment_idx++) { + auto segment = nodes[segment_idx].node.get(); + segment->CommitDropSegment(); + } } +} + +void ColumnDataCheckpointer::WriteToDisk() { + DropSegments(); + + // Analyze the candidate functions to select one of them to use for compression + auto analyze_result = DetectBestCompressionMethod(); + + // Initialize the compression for the selected function + D_ASSERT(analyze_result.size() == checkpoint_states.size()); + vector checkpoint_data(checkpoint_states.size()); + vector> compression_states(checkpoint_states.size()); + for (idx_t i = 0; i < analyze_result.size(); i++) { + if (!has_changes[i]) { + continue; + } + auto &analyze_state = analyze_result[i].analyze_state; + auto &function = analyze_result[i].function; - // now we need to write our segment - // we will first run an analyze step that determines which compression function to use - idx_t compression_idx; - auto analyze_state = DetectBestCompressionMethod(nodes, compression_idx); + auto &checkpoint_state = checkpoint_states[i]; + auto &col_data = checkpoint_state.get().column_data; - if (!analyze_state) { - throw FatalException("No suitable compression/storage method found to store column"); + checkpoint_data[i] = + ColumnDataCheckpointData(checkpoint_state, col_data, col_data.GetDatabase(), row_group, checkpoint_info); + compression_states[i] = function->init_compression(checkpoint_data[i], std::move(analyze_state)); } - // now that we have analyzed the compression functions we can start writing to disk - auto best_function = compression_functions[compression_idx]; - auto compress_state = best_function->init_compression(*this, std::move(analyze_state)); + // Scan over the existing segment + changes and compress the data + ScanSegments([&](Vector &scan_vector, idx_t count) { + for (idx_t i = 0; i < checkpoint_states.size(); i++) { + if (!has_changes[i]) { + continue; + } + auto &function = analyze_result[i].function; + auto &compression_state = compression_states[i]; + function->compress(*compression_state, scan_vector, count); + } + }); - ScanSegments( - nodes, [&](Vector &scan_vector, idx_t count) { best_function->compress(*compress_state, scan_vector, count); }); - best_function->compress_finalize(*compress_state); + // Finalize the compression + for (idx_t i = 0; i < checkpoint_states.size(); i++) { + if (!has_changes[i]) { + continue; + } + auto &function = analyze_result[i].function; + auto &compression_state = compression_states[i]; + function->compress_finalize(*compression_state); + } } -bool ColumnDataCheckpointer::HasChanges(const column_segment_vector_t &nodes) { +bool ColumnDataCheckpointer::HasChanges(ColumnData &col_data) { + auto &nodes = col_data.data.ReferenceSegments(); for (idx_t segment_idx = 0; segment_idx < nodes.size(); segment_idx++) { auto segment = nodes[segment_idx].node.get(); if (segment->segment_type == ColumnSegmentType::TRANSIENT) { @@ -223,9 +340,13 @@ bool ColumnDataCheckpointer::HasChanges(const column_segment_vector_t &nodes) { return false; } -void ColumnDataCheckpointer::WritePersistentSegments(column_segment_vector_t nodes) { +void ColumnDataCheckpointer::WritePersistentSegments(ColumnCheckpointState &state) { // all segments are persistent and there are no updates // we only need to write the metadata + + auto &col_data = state.column_data; + auto nodes = col_data.data.MoveSegments(); + for (idx_t segment_idx = 0; segment_idx < nodes.size(); segment_idx++) { auto segment = nodes[segment_idx].node.get(); auto pointer = segment->GetDataPointer(); @@ -240,28 +361,51 @@ void ColumnDataCheckpointer::WritePersistentSegments(column_segment_vector_t nod } } -void ColumnDataCheckpointer::Checkpoint(const column_segment_vector_t &nodes) { - D_ASSERT(!nodes.empty()); - has_changes = HasChanges(nodes); - // first check if any of the segments have changes - if (has_changes) { - WriteToDisk(nodes); +void ColumnDataCheckpointer::Checkpoint() { + for (idx_t i = 0; i < checkpoint_states.size(); i++) { + auto &state = checkpoint_states[i]; + auto &col_data = state.get().column_data; + has_changes.push_back(HasChanges(col_data)); } -} -void ColumnDataCheckpointer::FinalizeCheckpoint(column_segment_vector_t &&nodes) { - if (has_changes) { - nodes.clear(); - } else { - WritePersistentSegments(std::move(nodes)); + bool any_has_changes = false; + for (idx_t i = 0; i < has_changes.size(); i++) { + if (has_changes[i]) { + any_has_changes = true; + break; + } + } + if (!any_has_changes) { + // Nothing has undergone any changes, no need to checkpoint + // just move on to finalizing + return; } + + WriteToDisk(); } -CompressionFunction &ColumnDataCheckpointer::GetCompressionFunction(CompressionType compression_type) { - auto &db = GetDatabase(); - auto &column_type = GetType(); - auto &config = DBConfig::GetConfig(db); - return *config.GetCompressionFunction(compression_type, column_type.InternalType()); +void ColumnDataCheckpointer::FinalizeCheckpoint() { + for (idx_t i = 0; i < checkpoint_states.size(); i++) { + auto &state = checkpoint_states[i].get(); + auto &col_data = state.column_data; + if (has_changes[i]) { + // Move the existing segments out of the column data + // they will be destructed at the end of the scope + auto to_delete = col_data.data.MoveSegments(); + } else { + WritePersistentSegments(state); + } + + // reset the compression function + col_data.compression.reset(); + // replace the old tree with the new one + auto new_segments = state.new_tree.MoveSegments(); + auto l = col_data.data.Lock(); + for (auto &new_segment : new_segments) { + col_data.AppendSegment(l, std::move(new_segment.node)); + } + col_data.ClearUpdates(); + } } } // namespace duckdb diff --git a/src/duckdb/src/storage/table/standard_column_data.cpp b/src/duckdb/src/storage/table/standard_column_data.cpp index 506d04827..6b6311c3d 100644 --- a/src/duckdb/src/storage/table/standard_column_data.cpp +++ b/src/duckdb/src/storage/table/standard_column_data.cpp @@ -232,10 +232,29 @@ unique_ptr StandardColumnData::Checkpoint(RowGroup &row_g // to prevent reading the validity data immediately after it is checkpointed we first checkpoint the main column // this is necessary for concurrent checkpointing as due to the partial block manager checkpointed data might be // flushed to disk by a different thread than the one that wrote it, causing a data race - auto base_state = ColumnData::Checkpoint(row_group, checkpoint_info); - auto validity_state = validity.Checkpoint(row_group, checkpoint_info); + auto base_state = CreateCheckpointState(row_group, checkpoint_info.info.manager); + base_state->global_stats = BaseStatistics::CreateEmpty(type).ToUnique(); + auto validity_state_p = validity.CreateCheckpointState(row_group, checkpoint_info.info.manager); + validity_state_p->global_stats = BaseStatistics::CreateEmpty(validity.type).ToUnique(); + + auto &validity_state = *validity_state_p; auto &checkpoint_state = base_state->Cast(); - checkpoint_state.validity_state = std::move(validity_state); + checkpoint_state.validity_state = std::move(validity_state_p); + + auto &nodes = data.ReferenceSegments(); + if (nodes.empty()) { + // empty table: flush the empty list + return base_state; + } + + vector> checkpoint_states; + checkpoint_states.emplace_back(checkpoint_state); + checkpoint_states.emplace_back(validity_state); + + ColumnDataCheckpointer checkpointer(checkpoint_states, GetDatabase(), row_group, checkpoint_info); + checkpointer.Checkpoint(); + checkpointer.FinalizeCheckpoint(); + return base_state; } From 3be11b40868e259aa3654824549fcff3b75ac381 Mon Sep 17 00:00:00 2001 From: DuckDB Labs GitHub Bot Date: Thu, 9 Jan 2025 00:34:06 +0000 Subject: [PATCH 07/16] Update vendored DuckDB sources to 2ef707a8 --- .../extension/parquet/column_reader.cpp | 8 + .../parquet/include/column_reader.hpp | 4 + .../extension/parquet/parquet_extension.cpp | 8 +- .../extension/parquet/parquet_reader.cpp | 5 +- .../src/execution/aggregate_hashtable.cpp | 3 + .../csv_scanner/buffer_manager/csv_buffer.cpp | 4 +- .../buffer_manager/csv_buffer_manager.cpp | 9 +- .../buffer_manager/csv_file_handle.cpp | 2 +- .../csv_scanner/scanner/scanner_boundary.cpp | 46 +++-- .../scanner/string_value_scanner.cpp | 56 +++--- .../csv_scanner/sniffer/csv_sniffer.cpp | 11 +- .../csv_scanner/sniffer/type_detection.cpp | 26 +-- .../table_function/global_csv_state.cpp | 118 ++----------- .../operator/csv_scanner/util/csv_error.cpp | 163 ++++++++++++++++-- .../csv_scanner/util/csv_reader_options.cpp | 21 ++- .../src/function/scalar/sequence/nextval.cpp | 3 + .../src/function/scalar/string/length.cpp | 10 +- .../function/table/version/pragma_version.cpp | 6 +- .../operator/csv_scanner/csv_buffer.hpp | 14 +- .../operator/csv_scanner/csv_error.hpp | 37 ++-- .../csv_scanner/csv_reader_options.hpp | 5 +- .../operator/csv_scanner/scanner_boundary.hpp | 18 +- .../csv_scanner/string_value_scanner.hpp | 13 +- .../compression/dictionary/compression.hpp | 1 - .../expression/bind_operator_expression.cpp | 3 + .../planner/binder/statement/bind_create.cpp | 2 +- src/duckdb/src/storage/arena_allocator.cpp | 9 +- .../compression/dictionary/compression.cpp | 7 +- .../storage/serialization/serialize_nodes.cpp | 11 +- 29 files changed, 363 insertions(+), 260 deletions(-) diff --git a/src/duckdb/extension/parquet/column_reader.cpp b/src/duckdb/extension/parquet/column_reader.cpp index cf1f5ba50..8a2112c35 100644 --- a/src/duckdb/extension/parquet/column_reader.cpp +++ b/src/duckdb/extension/parquet/column_reader.cpp @@ -135,6 +135,14 @@ const SchemaElement &ColumnReader::Schema() const { return schema; } +optional_ptr ColumnReader::GetParentSchema() const { + return parent_schema; +} + +void ColumnReader::SetParentSchema(const SchemaElement &parent_schema_p) { + parent_schema = &parent_schema_p; +} + idx_t ColumnReader::FileIdx() const { return file_idx; } diff --git a/src/duckdb/extension/parquet/include/column_reader.hpp b/src/duckdb/extension/parquet/include/column_reader.hpp index dd89cadd5..23d4fc3d4 100644 --- a/src/duckdb/extension/parquet/include/column_reader.hpp +++ b/src/duckdb/extension/parquet/include/column_reader.hpp @@ -57,6 +57,9 @@ class ColumnReader { ParquetReader &Reader(); const LogicalType &Type() const; const SchemaElement &Schema() const; + optional_ptr GetParentSchema() const; + void SetParentSchema(const SchemaElement &parent_schema); + idx_t FileIdx() const; idx_t MaxDefine() const; idx_t MaxRepeat() const; @@ -140,6 +143,7 @@ class ColumnReader { protected: const SchemaElement &schema; + optional_ptr parent_schema; idx_t file_idx; idx_t max_define; diff --git a/src/duckdb/extension/parquet/parquet_extension.cpp b/src/duckdb/extension/parquet/parquet_extension.cpp index 8cbea8090..500b89919 100644 --- a/src/duckdb/extension/parquet/parquet_extension.cpp +++ b/src/duckdb/extension/parquet/parquet_extension.cpp @@ -313,9 +313,15 @@ static void InitializeParquetReader(ParquetReader &reader, const ParquetReadBind unordered_map field_id_to_column_index; auto &column_readers = reader.root_reader->Cast().child_readers; for (idx_t column_index = 0; column_index < column_readers.size(); column_index++) { - auto &column_schema = column_readers[column_index]->Schema(); + auto &column_reader = *column_readers[column_index]; + auto &column_schema = column_reader.Schema(); if (column_schema.__isset.field_id) { field_id_to_column_index[column_schema.field_id] = column_index; + } else if (column_reader.GetParentSchema()) { + auto &parent_column_schema = *column_reader.GetParentSchema(); + if (parent_column_schema.__isset.field_id) { + field_id_to_column_index[parent_column_schema.field_id] = column_index; + } } } diff --git a/src/duckdb/extension/parquet/parquet_reader.cpp b/src/duckdb/extension/parquet/parquet_reader.cpp index e6ce7aa92..1d2565a2d 100644 --- a/src/duckdb/extension/parquet/parquet_reader.cpp +++ b/src/duckdb/extension/parquet/parquet_reader.cpp @@ -418,9 +418,10 @@ unique_ptr ParquetReader::CreateReaderRecursive(ClientContext &con } if (is_repeated) { result_type = LogicalType::LIST(result_type); - return make_uniq(*this, result_type, s_ele, this_idx, max_define, max_repeat, - std::move(result)); + result = make_uniq(*this, result_type, s_ele, this_idx, max_define, max_repeat, + std::move(result)); } + result->SetParentSchema(s_ele); return result; } else { // leaf node if (!s_ele.__isset.type) { diff --git a/src/duckdb/src/execution/aggregate_hashtable.cpp b/src/duckdb/src/execution/aggregate_hashtable.cpp index 8a2dd448c..198b77fac 100644 --- a/src/duckdb/src/execution/aggregate_hashtable.cpp +++ b/src/duckdb/src/execution/aggregate_hashtable.cpp @@ -131,6 +131,9 @@ void GroupedAggregateHashTable::Abandon() { // Start over ClearPointerTable(); count = 0; + + // Resetting the id ensures the dict state is reset properly when needed + state.dict_state.dictionary_id = string(); } void GroupedAggregateHashTable::Repartition() { diff --git a/src/duckdb/src/execution/operator/csv_scanner/buffer_manager/csv_buffer.cpp b/src/duckdb/src/execution/operator/csv_scanner/buffer_manager/csv_buffer.cpp index 3677e0a75..c18c5f61e 100644 --- a/src/duckdb/src/execution/operator/csv_scanner/buffer_manager/csv_buffer.cpp +++ b/src/duckdb/src/execution/operator/csv_scanner/buffer_manager/csv_buffer.cpp @@ -58,7 +58,7 @@ void CSVBuffer::AllocateBuffer(idx_t buffer_size) { block = handle.GetBlockHandle(); } -idx_t CSVBuffer::GetBufferSize() { +idx_t CSVBuffer::GetBufferSize() const { return actual_buffer_size; } @@ -87,7 +87,7 @@ void CSVBuffer::Unpin() { } } -bool CSVBuffer::IsCSVFileLastBuffer() { +bool CSVBuffer::IsCSVFileLastBuffer() const { return last_buffer; } diff --git a/src/duckdb/src/execution/operator/csv_scanner/buffer_manager/csv_buffer_manager.cpp b/src/duckdb/src/execution/operator/csv_scanner/buffer_manager/csv_buffer_manager.cpp index 5f2823292..811689917 100644 --- a/src/duckdb/src/execution/operator/csv_scanner/buffer_manager/csv_buffer_manager.cpp +++ b/src/duckdb/src/execution/operator/csv_scanner/buffer_manager/csv_buffer_manager.cpp @@ -7,7 +7,7 @@ CSVBufferManager::CSVBufferManager(ClientContext &context_p, const CSVReaderOpti const idx_t file_idx_p, bool per_file_single_threaded_p, unique_ptr file_handle_p) : context(context_p), per_file_single_threaded(per_file_single_threaded_p), file_idx(file_idx_p), - file_path(file_path_p), buffer_size(CSVBuffer::CSV_BUFFER_SIZE) { + file_path(file_path_p), buffer_size(options.buffer_size_option.GetValue()) { D_ASSERT(!file_path.empty()); if (file_handle_p) { file_handle = std::move(file_handle_p); @@ -16,13 +16,6 @@ CSVBufferManager::CSVBufferManager(ClientContext &context_p, const CSVReaderOpti } is_pipe = file_handle->IsPipe(); skip_rows = options.dialect_options.skip_rows.GetValue(); - auto file_size = file_handle->FileSize(); - if (file_size > 0 && file_size < buffer_size) { - buffer_size = CSVBuffer::CSV_MINIMUM_BUFFER_SIZE; - } - if (options.buffer_size < buffer_size) { - buffer_size = options.buffer_size; - } Initialize(); } diff --git a/src/duckdb/src/execution/operator/csv_scanner/buffer_manager/csv_file_handle.cpp b/src/duckdb/src/execution/operator/csv_scanner/buffer_manager/csv_file_handle.cpp index 0a8c1e20c..73fbb4ed0 100644 --- a/src/duckdb/src/execution/operator/csv_scanner/buffer_manager/csv_file_handle.cpp +++ b/src/duckdb/src/execution/operator/csv_scanner/buffer_manager/csv_file_handle.cpp @@ -10,7 +10,7 @@ namespace duckdb { CSVFileHandle::CSVFileHandle(DBConfig &config, unique_ptr file_handle_p, const string &path_p, const CSVReaderOptions &options) : compression_type(options.compression), file_handle(std::move(file_handle_p)), - encoder(config, options.encoding, options.buffer_size), path(path_p) { + encoder(config, options.encoding, options.buffer_size_option.GetValue()), path(path_p) { can_seek = file_handle->CanSeek(); on_disk_file = file_handle->OnDiskFile(); file_size = file_handle->GetFileSize(); diff --git a/src/duckdb/src/execution/operator/csv_scanner/scanner/scanner_boundary.cpp b/src/duckdb/src/execution/operator/csv_scanner/scanner/scanner_boundary.cpp index 0a577d779..b0511bec6 100644 --- a/src/duckdb/src/execution/operator/csv_scanner/scanner/scanner_boundary.cpp +++ b/src/duckdb/src/execution/operator/csv_scanner/scanner/scanner_boundary.cpp @@ -16,7 +16,7 @@ CSVBoundary::CSVBoundary() : buffer_idx(0), buffer_pos(0), boundary_idx(0), end_ CSVIterator::CSVIterator() : is_set(false) { } -void CSVBoundary::Print() { +void CSVBoundary::Print() const { #ifndef DUCKDB_DISABLE_PRINT std::cout << "---Boundary: " << boundary_idx << " ---" << '\n'; std::cout << "Buffer Index: " << buffer_idx << '\n'; @@ -26,26 +26,39 @@ void CSVBoundary::Print() { #endif } -void CSVIterator::Print() { +void CSVIterator::Print() const { #ifndef DUCKDB_DISABLE_PRINT boundary.Print(); std::cout << "Is set: " << is_set << '\n'; #endif } -bool CSVIterator::Next(CSVBufferManager &buffer_manager) { +idx_t CSVIterator::BytesPerThread(const CSVReaderOptions &reader_options) { + const idx_t buffer_size = reader_options.buffer_size_option.GetValue(); + const idx_t max_row_size = reader_options.maximum_line_size.GetValue(); + const idx_t bytes_per_thread = buffer_size / CSVBuffer::ROWS_PER_BUFFER * ROWS_PER_THREAD; + if (bytes_per_thread < max_row_size) { + // If we are setting up the buffer size directly, we must make sure each thread will read the full buffer. + return max_row_size; + } + return bytes_per_thread; +} + +bool CSVIterator::Next(CSVBufferManager &buffer_manager, const CSVReaderOptions &reader_options) { if (!is_set) { return false; } + const auto bytes_per_thread = BytesPerThread(reader_options); + // If we are calling next this is not the first one anymore first_one = false; boundary.boundary_idx++; // This is our start buffer auto buffer = buffer_manager.GetBuffer(boundary.buffer_idx); - if (buffer->is_last_buffer && boundary.buffer_pos + CSVIterator::BYTES_PER_THREAD > buffer->actual_size) { + if (buffer->is_last_buffer && boundary.buffer_pos + bytes_per_thread > buffer->actual_size) { // 1) We are done with the current file return false; - } else if (boundary.buffer_pos + BYTES_PER_THREAD >= buffer->actual_size) { + } else if (boundary.buffer_pos + bytes_per_thread >= buffer->actual_size) { // 2) We still have data to scan in this file, we set the iterator accordingly. // We must move the buffer boundary.buffer_idx++; @@ -58,9 +71,9 @@ bool CSVIterator::Next(CSVBufferManager &buffer_manager) { } else { // 3) We are not done with the current buffer, hence we just move where we start within the buffer - boundary.buffer_pos += BYTES_PER_THREAD; + boundary.buffer_pos += bytes_per_thread; } - boundary.end_pos = boundary.buffer_pos + BYTES_PER_THREAD; + boundary.end_pos = boundary.buffer_pos + bytes_per_thread; SetCurrentPositionToBoundary(); return true; } @@ -85,20 +98,21 @@ void CSVIterator::SetCurrentPositionToBoundary() { pos.buffer_pos = boundary.buffer_pos; } -void CSVIterator::SetCurrentBoundaryToPosition(bool single_threaded) { +void CSVIterator::SetCurrentBoundaryToPosition(bool single_threaded, const CSVReaderOptions &reader_options) { if (single_threaded) { is_set = false; return; } + const auto bytes_per_thread = BytesPerThread(reader_options); + boundary.buffer_idx = pos.buffer_idx; if (pos.buffer_pos == 0) { - boundary.end_pos = CSVIterator::BYTES_PER_THREAD; + boundary.end_pos = bytes_per_thread; } else { - boundary.end_pos = ((pos.buffer_pos + CSVIterator::BYTES_PER_THREAD - 1) / CSVIterator::BYTES_PER_THREAD) * - CSVIterator::BYTES_PER_THREAD; + boundary.end_pos = ((pos.buffer_pos + bytes_per_thread - 1) / bytes_per_thread) * bytes_per_thread; } - boundary.buffer_pos = boundary.end_pos - CSVIterator::BYTES_PER_THREAD; + boundary.buffer_pos = boundary.end_pos - bytes_per_thread; is_set = true; } @@ -110,7 +124,13 @@ void CSVIterator::SetEnd(idx_t pos) { boundary.end_pos = pos; } -idx_t CSVIterator::GetGlobalCurrentPos() { +void CSVIterator::CheckIfDone() { + if (IsBoundarySet() && (pos.buffer_idx > boundary.buffer_idx || pos.buffer_pos > boundary.buffer_pos)) { + done = true; + } +} + +idx_t CSVIterator::GetGlobalCurrentPos() const { return pos.buffer_pos + buffer_size * pos.buffer_idx; } diff --git a/src/duckdb/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp b/src/duckdb/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp index 967660a8e..aeb305a55 100644 --- a/src/duckdb/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp +++ b/src/duckdb/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp @@ -14,19 +14,22 @@ #include namespace duckdb { + +constexpr idx_t StringValueScanner::LINE_FINDER_ID; + StringValueResult::StringValueResult(CSVStates &states, CSVStateMachine &state_machine, const shared_ptr &buffer_handle, Allocator &buffer_allocator, idx_t result_size_p, idx_t buffer_position, CSVErrorHandler &error_hander_p, CSVIterator &iterator_p, bool store_line_size_p, shared_ptr csv_file_scan_p, idx_t &lines_read_p, bool sniffing_p, - string path_p) + string path_p, idx_t scan_id) : ScannerResult(states, state_machine, result_size_p), number_of_columns(NumericCast(state_machine.dialect_options.num_cols)), null_padding(state_machine.options.null_padding), ignore_errors(state_machine.options.ignore_errors.GetValue()), extra_delimiter_bytes(state_machine.dialect_options.state_machine_options.delimiter.GetValue().size() - 1), error_handler(error_hander_p), iterator(iterator_p), store_line_size(store_line_size_p), csv_file_scan(std::move(csv_file_scan_p)), lines_read(lines_read_p), - current_errors(state_machine.options.IgnoreErrors()), sniffing(sniffing_p), path(std::move(path_p)) { + current_errors(scan_id, state_machine.options.IgnoreErrors()), sniffing(sniffing_p), path(std::move(path_p)) { // Vector information D_ASSERT(number_of_columns > 0); if (!buffer_handle) { @@ -681,7 +684,7 @@ bool LineError::HandleErrors(StringValueResult &result) { break; case MAXIMUM_LINE_SIZE: csv_error = CSVError::LineSizeError( - result.state_machine.options, cur_error.current_line_size, lines_per_batch, borked_line, + result.state_machine.options, lines_per_batch, borked_line, result.current_line_position.begin.GetGlobalPosition(result.requested_size, first_nl), result.path); break; case INVALID_STATE: @@ -702,7 +705,7 @@ bool LineError::HandleErrors(StringValueResult &result) { } result.error_handler.Error(csv_error); } - if (is_error_in_line) { + if (is_error_in_line && scan_id != StringValueScanner::LINE_FINDER_ID) { if (result.sniffing) { // If we are sniffing we just remove the line result.RemoveLastLine(); @@ -780,7 +783,7 @@ bool StringValueResult::AddRowInternal() { } current_line_position.begin = current_line_position.end; current_line_position.end = current_line_start; - if (current_line_size > state_machine.options.maximum_line_size) { + if (current_line_size > state_machine.options.maximum_line_size.GetValue()) { current_errors.Insert(MAXIMUM_LINE_SIZE, 1, chunk_col_id, last_position, current_line_size); } if (!state_machine.options.null_padding) { @@ -827,7 +830,7 @@ bool StringValueResult::AddRowInternal() { } else { // If we are not null-padding this is an error if (!state_machine.options.IgnoreErrors()) { - bool first_nl; + bool first_nl = false; auto borked_line = current_line_position.ReconstructCurrentLine(first_nl, buffer_handles, PrintErrorLine()); LinesPerBoundary lines_per_batch(iterator.GetBoundaryIdx(), lines_read); @@ -938,8 +941,8 @@ StringValueScanner::StringValueScanner(idx_t scanner_idx_p, const shared_ptrcontext), result_size, iterator.pos.buffer_pos, *error_handler, iterator, buffer_manager->context.client_data->debug_set_max_line_length, csv_file_scan, lines_read, sniffing, - buffer_manager->GetFilePath()) { - iterator.buffer_size = state_machine->options.buffer_size; + buffer_manager->GetFilePath(), scanner_idx_p) { + iterator.buffer_size = state_machine->options.buffer_size_option.GetValue(); } StringValueScanner::StringValueScanner(const shared_ptr &buffer_manager, @@ -950,8 +953,8 @@ StringValueScanner::StringValueScanner(const shared_ptr &buffe result(states, *state_machine, cur_buffer_handle, Allocator::DefaultAllocator(), result_size, iterator.pos.buffer_pos, *error_handler, iterator, buffer_manager->context.client_data->debug_set_max_line_length, csv_file_scan, lines_read, sniffing, - buffer_manager->GetFilePath()) { - iterator.buffer_size = state_machine->options.buffer_size; + buffer_manager->GetFilePath(), 0) { + iterator.buffer_size = state_machine->options.buffer_size_option.GetValue(); } unique_ptr StringValueScanner::GetCSVScanner(ClientContext &context, CSVReaderOptions &options) { @@ -1064,7 +1067,7 @@ void StringValueScanner::Flush(DataChunk &insert_chunk) { } result.borked_rows.insert(line_error++); D_ASSERT(state_machine->options.ignore_errors.GetValue()); - // We are ignoring errors. We must continue but ignoring borked rows + // We are ignoring errors. We must continue but ignoring borked-rows for (; line_error < parse_chunk.size(); line_error++) { if (!inserted_column_data.validity.RowIsValid(line_error) && parse_column_data.validity.RowIsValid(line_error)) { @@ -1622,14 +1625,19 @@ bool StringValueScanner::IsRowValid(CSVIterator ¤t_iterator) const { return false; } constexpr idx_t result_size = 1; - auto scan_finder = - make_uniq(0U, buffer_manager, state_machine_strict, make_shared_ptr(), - csv_file_scan, false, current_iterator, result_size); + auto scan_finder = make_uniq(StringValueScanner::LINE_FINDER_ID, buffer_manager, + state_machine_strict, make_shared_ptr(), + csv_file_scan, false, current_iterator, result_size); auto &tuples = scan_finder->ParseChunk(); current_iterator.pos = scan_finder->GetIteratorPosition(); - return (tuples.number_of_rows == 1 || tuples.first_line_is_comment) && tuples.borked_rows.empty() && - !tuples.current_errors.HasError(); - ; + bool has_error = false; + if (tuples.current_errors.HasError()) { + if (tuples.current_errors.Size() != 1 || !tuples.current_errors.HasErrorType(MAXIMUM_LINE_SIZE)) { + // We ignore maximum line size errors + has_error = true; + } + } + return (tuples.number_of_rows == 1 || tuples.first_line_is_comment) && !has_error && tuples.borked_rows.empty(); } ValidRowInfo StringValueScanner::TryRow(CSVState state, idx_t start_pos, idx_t end_pos) const { @@ -1641,9 +1649,6 @@ ValidRowInfo StringValueScanner::TryRow(CSVState state, idx_t start_pos, idx_t e auto iterator_start = current_iterator; idx_t current_pos = current_iterator.pos.buffer_pos; current_iterator.SetEnd(iterator.GetEndPos()); - if (iterator.GetEndPos() == current_pos) { - return {false, current_pos, current_iterator.pos.buffer_idx, current_iterator.pos.buffer_pos, quoted}; - } if (IsRowValid(current_iterator)) { if (!quoted) { quoted = FirstValueEndsOnQuote(iterator_start); @@ -1715,12 +1720,19 @@ void StringValueScanner::SetStart() { iterator.done = true; } else { bool mock; - SkipUntilState(CSVState::STANDARD_NEWLINE, CSVState::RECORD_SEPARATOR, iterator, mock); + if (!SkipUntilState(CSVState::STANDARD_NEWLINE, CSVState::RECORD_SEPARATOR, iterator, mock)) { + iterator.CheckIfDone(); + } } } else { iterator.pos.buffer_pos = best_row.start_pos; - iterator.done = iterator.pos.buffer_pos == cur_buffer_handle->actual_size; + bool is_this_the_end = + best_row.start_pos >= cur_buffer_handle->actual_size && cur_buffer_handle->is_last_buffer; + if (is_this_the_end) { + iterator.done = true; + } } + // 4. We have an error, if we have an error, we let life go on, the scanner will either ignore it // or throw. result.last_position = {iterator.pos.buffer_idx, iterator.pos.buffer_pos, result.buffer_size}; diff --git a/src/duckdb/src/execution/operator/csv_scanner/sniffer/csv_sniffer.cpp b/src/duckdb/src/execution/operator/csv_scanner/sniffer/csv_sniffer.cpp index 08311cfe3..c8740ebde 100644 --- a/src/duckdb/src/execution/operator/csv_scanner/sniffer/csv_sniffer.cpp +++ b/src/duckdb/src/execution/operator/csv_scanner/sniffer/csv_sniffer.cpp @@ -205,15 +205,8 @@ SnifferResult CSVSniffer::SniffCSV(const bool force_match) { buffer_manager->ResetBufferManager(); } buffer_manager->sniffing = false; - if (!best_candidate->error_handler->errors.empty() && !options.ignore_errors.GetValue()) { - for (auto &error_vector : best_candidate->error_handler->errors) { - for (auto &error : error_vector.second) { - if (error.type == MAXIMUM_LINE_SIZE) { - // If it's a maximum line size error, we can do it now. - error_handler->Error(error); - } - } - } + if (best_candidate->error_handler->AnyErrors() && !options.ignore_errors.GetValue()) { + best_candidate->error_handler->ErrorIfTypeExists(MAXIMUM_LINE_SIZE); } D_ASSERT(best_sql_types_candidates_per_column_idx.size() == names.size()); // We are done, Set the CSV Options in the reference. Construct and return the result. diff --git a/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_detection.cpp b/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_detection.cpp index e7a5237af..49bf105a9 100644 --- a/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_detection.cpp +++ b/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_detection.cpp @@ -425,19 +425,9 @@ void CSVSniffer::DetectTypes() { SetUserDefinedDateTimeFormat(*candidate->state_machine); // Parse chunk and read csv with info candidate auto &data_chunk = candidate->ParseChunk().ToChunk(); - if (!candidate->error_handler->errors.empty()) { - bool break_loop = false; - for (auto &errors : candidate->error_handler->errors) { - for (auto &error : errors.second) { - if (error.type != CSVErrorType::MAXIMUM_LINE_SIZE) { - break_loop = true; - break; - } - } - } - if (break_loop && !candidate->state_machine->options.ignore_errors.GetValue()) { - continue; - } + if (candidate->error_handler->AnyErrors() && !candidate->error_handler->HasError(MAXIMUM_LINE_SIZE) && + !candidate->state_machine->options.ignore_errors.GetValue()) { + continue; } idx_t start_idx_detection = 0; idx_t chunk_size = data_chunk.size(); @@ -463,11 +453,11 @@ void CSVSniffer::DetectTypes() { // it's good if the dialect creates more non-varchar columns, but only if we sacrifice < 30% of // best_num_cols. - if (!best_candidate || - (varchar_cols(info_sql_types_candidates.size())>( - static_cast(max_columns_found) * 0.7) && - (!options.ignore_errors.GetValue() || candidate->error_handler->errors.size() < min_errors))) { - min_errors = candidate->error_handler->errors.size(); + const idx_t number_of_errors = candidate->error_handler->GetSize(); + if (!best_candidate || (varchar_cols(info_sql_types_candidates.size())>( + static_cast(max_columns_found) * 0.7) && + (!options.ignore_errors.GetValue() || number_of_errors < min_errors))) { + min_errors = number_of_errors; best_header_row.clear(); // we have a new best_options candidate best_candidate = std::move(candidate); diff --git a/src/duckdb/src/execution/operator/csv_scanner/table_function/global_csv_state.cpp b/src/duckdb/src/execution/operator/csv_scanner/table_function/global_csv_state.cpp index f6d0d386e..b1a4a6165 100644 --- a/src/duckdb/src/execution/operator/csv_scanner/table_function/global_csv_state.cpp +++ b/src/duckdb/src/execution/operator/csv_scanner/table_function/global_csv_state.cpp @@ -1,5 +1,4 @@ #include "duckdb/execution/operator/csv_scanner/global_csv_state.hpp" - #include "duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp" #include "duckdb/execution/operator/csv_scanner/scanner_boundary.hpp" #include "duckdb/execution/operator/csv_scanner/skip_scanner.hpp" @@ -28,7 +27,8 @@ CSVGlobalState::CSVGlobalState(ClientContext &context_p, const shared_ptrstart_iterator.done && file_scans.size() < files.size()) { - file_scans.emplace_back(make_uniq(context, files[++cur_file_idx], options, cur_file_idx, bind_data, + cur_file_idx++; + file_scans.emplace_back(make_uniq(context, files[cur_file_idx], options, cur_file_idx, bind_data, column_ids, file_schema, false)); } // There are situations where we only support single threaded scanning @@ -38,7 +38,7 @@ CSVGlobalState::CSVGlobalState(ClientContext &context_p, const shared_ptrstart_iterator; - current_boundary.SetCurrentBoundaryToPosition(single_threaded); + current_boundary.SetCurrentBoundaryToPosition(single_threaded, options); if (current_boundary.done && context.client_data->debug_set_max_line_length) { context.client_data->debug_max_line_length = current_boundary.pos.buffer_pos; } @@ -124,7 +124,7 @@ unique_ptr CSVGlobalState::Next(optional_ptrstart_iterator; - current_boundary.SetCurrentBoundaryToPosition(single_threaded); + current_boundary.SetCurrentBoundaryToPosition(single_threaded, bind_data.options); current_buffer_in_use = make_shared_ptr(*file_scans.back()->buffer_manager, current_boundary.GetBufferIdx()); @@ -158,7 +158,7 @@ unique_ptr CSVGlobalState::Next(optional_ptrbuffer_tracker = current_buffer_in_use; // We then produce the next boundary - if (!current_boundary.Next(*current_file.buffer_manager)) { + if (!current_boundary.Next(*current_file.buffer_manager, bind_data.options)) { // This means we are done scanning the current file do { auto current_file_idx = file_scans.back()->file_idx + 1; @@ -169,7 +169,7 @@ unique_ptr CSVGlobalState::Next(optional_ptrstart_iterator; - current_boundary.SetCurrentBoundaryToPosition(single_threaded); + current_boundary.SetCurrentBoundaryToPosition(single_threaded, bind_data.options); current_buffer_in_use = make_shared_ptr(*file_scans.back()->buffer_manager, current_boundary.GetBufferIdx()); } else { @@ -188,8 +188,8 @@ idx_t CSVGlobalState::MaxThreads() const { if (single_threaded || !file_scans.front()->on_disk_file) { return system_threads; } - const idx_t total_threads = file_scans.front()->file_size / CSVIterator::BYTES_PER_THREAD + 1; - + const idx_t bytes_per_thread = CSVIterator::BytesPerThread(file_scans.front()->options); + const idx_t total_threads = file_scans.front()->file_size / bytes_per_thread + 1; if (total_threads < system_threads) { return total_threads; } @@ -217,42 +217,6 @@ void CSVGlobalState::DecrementThread() { } } -bool IsCSVErrorAcceptedReject(CSVErrorType type) { - switch (type) { - case CSVErrorType::CAST_ERROR: - case CSVErrorType::TOO_MANY_COLUMNS: - case CSVErrorType::TOO_FEW_COLUMNS: - case CSVErrorType::MAXIMUM_LINE_SIZE: - case CSVErrorType::UNTERMINATED_QUOTES: - case CSVErrorType::INVALID_UNICODE: - case CSVErrorType::INVALID_STATE: - return true; - default: - return false; - } -} - -string CSVErrorTypeToEnum(CSVErrorType type) { - switch (type) { - case CSVErrorType::CAST_ERROR: - return "CAST"; - case CSVErrorType::TOO_FEW_COLUMNS: - return "MISSING COLUMNS"; - case CSVErrorType::TOO_MANY_COLUMNS: - return "TOO MANY COLUMNS"; - case CSVErrorType::MAXIMUM_LINE_SIZE: - return "LINE SIZE OVER MAXIMUM"; - case CSVErrorType::UNTERMINATED_QUOTES: - return "UNQUOTED VALUE"; - case CSVErrorType::INVALID_UNICODE: - return "INVALID UNICODE"; - case CSVErrorType::INVALID_STATE: - return "INVALID STATE"; - default: - throw InternalException("CSV Error is not valid to be stored in a Rejects Table"); - } -} - void FillScanErrorTable(InternalAppender &scan_appender, idx_t scan_idx, idx_t file_idx, CSVFileScan &file) { CSVReaderOptions &options = file.options; // Add the row to the rejects table @@ -326,70 +290,10 @@ void CSVGlobalState::FillRejectsTable() const { InternalAppender scans_appender(context, scans_table); idx_t scan_idx = context.transaction.GetActiveQuery(); for (auto &file : file_scans) { - idx_t file_idx = rejects->GetCurrentFileIndex(scan_idx); + const idx_t file_idx = rejects->GetCurrentFileIndex(scan_idx); auto file_name = file->file_path; - auto &errors = file->error_handler->errors; - // We first insert the file into the file scans table - for (auto &error_vector : errors) { - for (auto &error : error_vector.second) { - if (!IsCSVErrorAcceptedReject(error.type)) { - continue; - } - // short circuit if we already have too many rejects - if (limit == 0 || rejects->count < limit) { - if (limit != 0 && rejects->count >= limit) { - break; - } - rejects->count++; - auto row_line = file->error_handler->GetLine(error.error_info); - auto col_idx = error.column_idx; - // Add the row to the rejects table - errors_appender.BeginRow(); - // 1. Scan Id - errors_appender.Append(scan_idx); - // 2. File Id - errors_appender.Append(file_idx); - // 3. Row Line - errors_appender.Append(row_line); - // 4. Byte Position of the row error - errors_appender.Append(error.row_byte_position + 1); - // 5. Byte Position where error occurred - if (!error.byte_position.IsValid()) { - // This means this error comes from a flush, and we don't support this yet, so we give it - // a null - errors_appender.Append(Value()); - } else { - errors_appender.Append(error.byte_position.GetIndex() + 1); - } - // 6. Column Index - if (error.type == CSVErrorType::MAXIMUM_LINE_SIZE) { - errors_appender.Append(Value()); - } else { - errors_appender.Append(col_idx + 1); - } - // 7. Column Name (If Applicable) - switch (error.type) { - case CSVErrorType::TOO_MANY_COLUMNS: - case CSVErrorType::MAXIMUM_LINE_SIZE: - errors_appender.Append(Value()); - break; - case CSVErrorType::TOO_FEW_COLUMNS: - D_ASSERT(bind_data.return_names.size() > col_idx + 1); - errors_appender.Append(string_t(bind_data.return_names[col_idx + 1])); - break; - default: - errors_appender.Append(string_t(bind_data.return_names[col_idx])); - } - // 8. Error Type - errors_appender.Append(string_t(CSVErrorTypeToEnum(error.type))); - // 9. Original CSV Line - errors_appender.Append(string_t(error.csv_row)); - // 10. Full Error Message - errors_appender.Append(string_t(error.error_message)); - errors_appender.EndRow(); - } - } - } + file->error_handler->FillRejectsTable(errors_appender, file_idx, scan_idx, *file, *rejects, bind_data, + limit); if (rejects->count != 0) { rejects->count = 0; FillScanErrorTable(scans_appender, scan_idx, file_idx, *file); diff --git a/src/duckdb/src/execution/operator/csv_scanner/util/csv_error.cpp b/src/duckdb/src/execution/operator/csv_scanner/util/csv_error.cpp index 5c01d1fe9..f77a93ac0 100644 --- a/src/duckdb/src/execution/operator/csv_scanner/util/csv_error.cpp +++ b/src/duckdb/src/execution/operator/csv_scanner/util/csv_error.cpp @@ -1,7 +1,10 @@ #include "duckdb/execution/operator/csv_scanner/csv_error.hpp" #include "duckdb/common/exception/conversion_exception.hpp" #include "duckdb/common/string_util.hpp" - +#include "duckdb/function/table/read_csv.hpp" +#include "duckdb/execution/operator/persistent/csv_rejects_table.hpp" +#include "duckdb/execution/operator/csv_scanner/csv_file_scanner.hpp" +#include "duckdb/main/appender.hpp" #include namespace duckdb { @@ -41,11 +44,11 @@ void CSVErrorHandler::ThrowError(const CSVError &csv_error) { } } -void CSVErrorHandler::Error(CSVError csv_error, bool force_error) { +void CSVErrorHandler::Error(const CSVError &csv_error, bool force_error) { lock_guard parallel_lock(main_mutex); if ((ignore_errors && !force_error) || (PrintLineNumber(csv_error) && !CanGetLine(csv_error.GetBoundaryIndex()))) { // We store this error, we can't throw it now, or we are ignoring it - errors[csv_error.error_info].push_back(std::move(csv_error)); + errors.push_back(csv_error); return; } // Otherwise we can throw directly @@ -58,10 +61,19 @@ void CSVErrorHandler::ErrorIfNeeded() { // Nothing to error return; } - CSVError first_error = errors.begin()->second[0]; - if (CanGetLine(first_error.error_info.boundary_idx)) { - ThrowError(first_error); + if (CanGetLine(errors[0].error_info.boundary_idx)) { + ThrowError(errors[0]); + } +} + +void CSVErrorHandler::ErrorIfTypeExists(CSVErrorType error_type) { + lock_guard parallel_lock(main_mutex); + for (auto &error : errors) { + if (error.type == error_type) { + // If it's a maximum line size error, we can do it now. + ThrowError(error); + } } } @@ -84,6 +96,131 @@ bool CSVErrorHandler::AnyErrors() { return !errors.empty(); } +bool CSVErrorHandler::HasError(const CSVErrorType error_type) { + lock_guard parallel_lock(main_mutex); + for (const auto &er : errors) { + if (er.type == error_type) { + return true; + } + } + return false; +} + +idx_t CSVErrorHandler::GetSize() { + lock_guard parallel_lock(main_mutex); + return errors.size(); +} + +bool IsCSVErrorAcceptedReject(CSVErrorType type) { + switch (type) { + case CSVErrorType::INVALID_STATE: + case CSVErrorType::CAST_ERROR: + case CSVErrorType::TOO_MANY_COLUMNS: + case CSVErrorType::TOO_FEW_COLUMNS: + case CSVErrorType::MAXIMUM_LINE_SIZE: + case CSVErrorType::UNTERMINATED_QUOTES: + case CSVErrorType::INVALID_UNICODE: + return true; + default: + return false; + } +} +string CSVErrorTypeToEnum(CSVErrorType type) { + switch (type) { + case CSVErrorType::CAST_ERROR: + return "CAST"; + case CSVErrorType::TOO_FEW_COLUMNS: + return "MISSING COLUMNS"; + case CSVErrorType::TOO_MANY_COLUMNS: + return "TOO MANY COLUMNS"; + case CSVErrorType::MAXIMUM_LINE_SIZE: + return "LINE SIZE OVER MAXIMUM"; + case CSVErrorType::UNTERMINATED_QUOTES: + return "UNQUOTED VALUE"; + case CSVErrorType::INVALID_UNICODE: + return "INVALID UNICODE"; + case CSVErrorType::INVALID_STATE: + return "INVALID STATE"; + default: + throw InternalException("CSV Error is not valid to be stored in a Rejects Table"); + } +} + +void CSVErrorHandler::FillRejectsTable(InternalAppender &errors_appender, const idx_t file_idx, const idx_t scan_idx, + const CSVFileScan &file, CSVRejectsTable &rejects, const ReadCSVData &bind_data, + const idx_t limit) { + lock_guard parallel_lock(main_mutex); + // We first insert the file into the file scans table + for (auto &error : file.error_handler->errors) { + if (!IsCSVErrorAcceptedReject(error.type)) { + continue; + } + // short circuit if we already have too many rejects + if (limit == 0 || rejects.count < limit) { + if (limit != 0 && rejects.count >= limit) { + break; + } + rejects.count++; + const auto row_line = file.error_handler->GetLineInternal(error.error_info); + const auto col_idx = error.column_idx; + // Add the row to the rejects table + errors_appender.BeginRow(); + // 1. Scan ID + errors_appender.Append(scan_idx); + // 2. File ID + errors_appender.Append(file_idx); + // 3. Row Line + errors_appender.Append(row_line); + // 4. Byte Position of the row error + errors_appender.Append(error.row_byte_position + 1); + // 5. Byte Position where error occurred + if (!error.byte_position.IsValid()) { + // This means this error comes from a flush, and we don't support this yet, so we give it + // a null + errors_appender.Append(Value()); + } else { + errors_appender.Append(error.byte_position.GetIndex() + 1); + } + // 6. Column Index + if (error.type == CSVErrorType::MAXIMUM_LINE_SIZE) { + errors_appender.Append(Value()); + } else { + errors_appender.Append(col_idx + 1); + } + // 7. Column Name (If Applicable) + switch (error.type) { + case CSVErrorType::TOO_MANY_COLUMNS: + case CSVErrorType::MAXIMUM_LINE_SIZE: + errors_appender.Append(Value()); + break; + case CSVErrorType::TOO_FEW_COLUMNS: + D_ASSERT(bind_data.return_names.size() > col_idx + 1); + errors_appender.Append(string_t(bind_data.return_names[col_idx + 1])); + break; + default: + errors_appender.Append(string_t(bind_data.return_names[col_idx])); + } + // 8. Error Type + errors_appender.Append(string_t(CSVErrorTypeToEnum(error.type))); + // 9. Original CSV Line + errors_appender.Append(string_t(error.csv_row)); + // 10. Full Error Message + errors_appender.Append(string_t(error.error_message)); + errors_appender.EndRow(); + } + } +} + +idx_t CSVErrorHandler::GetMaxLineLength() { + lock_guard parallel_lock(main_mutex); + return max_line_length; +} + +void CSVErrorHandler::DontPrintErrorLine() { + lock_guard parallel_lock(main_mutex); + print_line = false; +} + void CSVErrorHandler::SetIgnoreErrors(bool ignore_errors_p) { lock_guard parallel_lock(main_mutex); ignore_errors = ignore_errors_p; @@ -115,7 +252,6 @@ CSVError CSVError::ColumnTypesError(case_insensitive_map_t sql_types_per_ auto it = sql_types_per_column.find(names[i]); if (it != sql_types_per_column.end()) { sql_types_per_column.erase(names[i]); - continue; } } if (sql_types_per_column.empty()) { @@ -165,14 +301,14 @@ CSVError CSVError::CastError(const CSVReaderOptions &options, string &column_nam how_to_fix_it.str(), current_path); } -CSVError CSVError::LineSizeError(const CSVReaderOptions &options, idx_t actual_size, LinesPerBoundary error_info, - string &csv_row, idx_t byte_position, const string ¤t_path) { +CSVError CSVError::LineSizeError(const CSVReaderOptions &options, LinesPerBoundary error_info, string &csv_row, + idx_t byte_position, const string ¤t_path) { std::ostringstream error; - error << "Maximum line size of " << options.maximum_line_size << " bytes exceeded. "; - error << "Actual Size:" << actual_size << " bytes." << '\n'; + error << "Maximum line size of " << options.maximum_line_size.GetValue() << " bytes exceeded. "; + error << "Actual Size:" << csv_row.size() << " bytes." << '\n'; std::ostringstream how_to_fix_it; - how_to_fix_it << "Possible Solution: Change the maximum length size, e.g., max_line_size=" << actual_size + 1 + how_to_fix_it << "Possible Solution: Change the maximum length size, e.g., max_line_size=" << csv_row.size() + 2 << "\n"; return CSVError(error.str(), MAXIMUM_LINE_SIZE, 0, csv_row, error_info, byte_position, byte_position, options, @@ -301,6 +437,9 @@ CSVError CSVError::SniffingError(const CSVReaderOptions &options, const string & } error << "* Check you are using the correct file compression, otherwise set it (e.g., compression = \'zstd\')" << '\n'; + error << "* Be sure that the maximum line size is set to an appropriate value, otherwise set it (e.g., " + "max_line_size=10000000)" + << "\n"; if (options.dialect_options.state_machine_options.rfc_4180.GetValue() != false || !options.dialect_options.state_machine_options.rfc_4180.IsSetByUser()) { 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 1a2ee65da..ac18d42eb 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 @@ -250,7 +250,7 @@ void CSVReaderOptions::SetReadOption(const string &loption, const Value &value, if (line_size < 0) { throw BinderException("Invalid value for MAX_LINE_SIZE parameter: it cannot be smaller than 0"); } - maximum_line_size = NumericCast(line_size); + maximum_line_size.Set(NumericCast(line_size)); } else if (loption == "date_format" || loption == "dateformat") { string format = ParseString(value, loption); SetDateFormat(LogicalTypeId::DATE, format, true); @@ -260,8 +260,8 @@ void CSVReaderOptions::SetReadOption(const string &loption, const Value &value, } else if (loption == "ignore_errors") { ignore_errors.Set(ParseBoolean(value, loption)); } else if (loption == "buffer_size") { - buffer_size = NumericCast(ParseInteger(value, loption)); - if (buffer_size == 0) { + buffer_size_option.Set(NumericCast(ParseInteger(value, loption))); + if (buffer_size_option == 0) { throw InvalidInputException("Buffer Size option must be higher than 0"); } } else if (loption == "decimal_separator") { @@ -546,6 +546,18 @@ void CSVReaderOptions::Verify() { if (rejects_limit != 0 && !store_rejects.GetValue()) { throw BinderException("REJECTS_LIMIT option is only supported when REJECTS_TABLE is set to a table name"); } + // Validate CSV Buffer and max_line_size do not conflict. + if (buffer_size_option.IsSetByUser() && maximum_line_size.IsSetByUser()) { + if (buffer_size_option.GetValue() < maximum_line_size.GetValue()) { + throw BinderException("BUFFER_SIZE option was set to %d, while MAX_LINE_SIZE was set to %d. BUFFER_SIZE " + "must have always be set to value bigger than MAX_LINE_SIZE", + buffer_size_option.GetValue(), maximum_line_size.GetValue()); + } + } else if (maximum_line_size.IsSetByUser() && maximum_line_size.GetValue() > max_line_size_default) { + // If the max line size is set by the user and bigger than we have by default, we make it part of our buffer + // size decision. + buffer_size_option.Set(CSVBuffer::ROWS_PER_BUFFER * maximum_line_size.GetValue(), false); + } } bool GetBooleanValue(const pair &option) { @@ -727,7 +739,7 @@ void CSVReaderOptions::ToNamedParameters(named_parameter_map_t &named_params) co if (rfc_4180.IsSetByUser()) { named_params["rfc_4180"] = Value(GetRFC4180()); } - named_params["max_line_size"] = Value::BIGINT(NumericCast(maximum_line_size)); + named_params["max_line_size"] = Value::BIGINT(NumericCast(maximum_line_size.GetValue())); if (dialect_options.skip_rows.IsSetByUser()) { named_params["skip"] = Value::UBIGINT(GetSkipRows()); } @@ -748,7 +760,6 @@ void CSVReaderOptions::ToNamedParameters(named_parameter_map_t &named_params) co named_params["column_names"] = StringVectorToValue(name_list); } named_params["all_varchar"] = Value::BOOLEAN(all_varchar); - named_params["maximum_line_size"] = Value::BIGINT(NumericCast(maximum_line_size)); } } // namespace duckdb diff --git a/src/duckdb/src/function/scalar/sequence/nextval.cpp b/src/duckdb/src/function/scalar/sequence/nextval.cpp index 7e19dae7d..6738383dc 100644 --- a/src/duckdb/src/function/scalar/sequence/nextval.cpp +++ b/src/duckdb/src/function/scalar/sequence/nextval.cpp @@ -91,6 +91,9 @@ static void NextValFunction(DataChunk &args, ExpressionState &state, Vector &res static unique_ptr NextValBind(ScalarFunctionBindInput &bind_input, ScalarFunction &, vector> &arguments) { + if (arguments[0]->HasParameter() || arguments[0]->return_type.id() == LogicalTypeId::UNKNOWN) { + throw ParameterNotResolvedException(); + } if (!arguments[0]->IsFoldable()) { throw NotImplementedException( "currval/nextval requires a constant sequence - non-constant sequences are no longer supported"); diff --git a/src/duckdb/src/function/scalar/string/length.cpp b/src/duckdb/src/function/scalar/string/length.cpp index f2ec8bae1..538646419 100644 --- a/src/duckdb/src/function/scalar/string/length.cpp +++ b/src/duckdb/src/function/scalar/string/length.cpp @@ -110,12 +110,14 @@ static void ArrayLengthFunction(DataChunk &args, ExpressionState &state, Vector static unique_ptr ArrayOrListLengthBind(ClientContext &context, ScalarFunction &bound_function, vector> &arguments) { - if (arguments[0]->HasParameter()) { + if (arguments[0]->HasParameter() || arguments[0]->return_type.id() == LogicalTypeId::UNKNOWN) { throw ParameterNotResolvedException(); } - if (arguments[0]->return_type.id() == LogicalTypeId::ARRAY) { + + const auto &arg_type = arguments[0]->return_type.id(); + if (arg_type == LogicalTypeId::ARRAY) { bound_function.function = ArrayLengthFunction; - } else if (arguments[0]->return_type.id() == LogicalTypeId::LIST) { + } else if (arg_type == LogicalTypeId::LIST) { bound_function.function = ListLengthFunction; } else { // Unreachable @@ -183,7 +185,7 @@ static void ArrayLengthBinaryFunction(DataChunk &args, ExpressionState &state, V static unique_ptr ArrayOrListLengthBinaryBind(ClientContext &context, ScalarFunction &bound_function, vector> &arguments) { - if (arguments[0]->HasParameter()) { + if (arguments[0]->HasParameter() || arguments[0]->return_type.id() == LogicalTypeId::UNKNOWN) { throw ParameterNotResolvedException(); } auto type = arguments[0]->return_type; diff --git a/src/duckdb/src/function/table/version/pragma_version.cpp b/src/duckdb/src/function/table/version/pragma_version.cpp index 6bb466621..28c14cfbc 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 "4-dev4108" +#define DUCKDB_PATCH_VERSION "4-dev4166" #endif #ifndef DUCKDB_MINOR_VERSION #define DUCKDB_MINOR_VERSION 1 @@ -8,10 +8,10 @@ #define DUCKDB_MAJOR_VERSION 1 #endif #ifndef DUCKDB_VERSION -#define DUCKDB_VERSION "v1.1.4-dev4108" +#define DUCKDB_VERSION "v1.1.4-dev4166" #endif #ifndef DUCKDB_SOURCE_ID -#define DUCKDB_SOURCE_ID "acdbf60889" +#define DUCKDB_SOURCE_ID "c28ce39350" #endif #include "duckdb/function/table/system_functions.hpp" #include "duckdb/main/database.hpp" diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_buffer.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_buffer.hpp index 039c06abe..99ce3c5ba 100644 --- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_buffer.hpp +++ b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_buffer.hpp @@ -55,10 +55,10 @@ class CSVBuffer { shared_ptr Next(CSVFileHandle &file_handle, idx_t buffer_size, idx_t file_number, bool &has_seaked); //! Gets the buffer actual size - idx_t GetBufferSize(); + idx_t GetBufferSize() const; //! If this buffer is the last buffer of the CSV File - bool IsCSVFileLastBuffer(); + bool IsCSVFileLastBuffer() const; //! Allocates internal buffer, sets 'block' and 'handle' variables. void AllocateBuffer(idx_t buffer_size); @@ -77,13 +77,9 @@ class CSVBuffer { } //! By default, we use CSV_BUFFER_SIZE to allocate each buffer - //! TODO: Should benchmarks other values - static constexpr idx_t CSV_BUFFER_SIZE = 32000000; // 32MB - //! In case the file has a size < 32MB, we will use this size instead - //! This is to avoid mallocing a lot of memory for a small file - //! And if it's a compressed file we can't use the actual size of the file - static constexpr idx_t CSV_MINIMUM_BUFFER_SIZE = 8000000; // 8MB - //! If this is the last buffer of the CSV File + static constexpr idx_t ROWS_PER_BUFFER = 16; + static constexpr idx_t MIN_ROWS_PER_BUFFER = 4; + bool last_buffer = false; private: diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_error.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_error.hpp index 6dd8a22ec..a31fd6190 100644 --- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_error.hpp +++ b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_error.hpp @@ -17,9 +17,12 @@ #include "duckdb/execution/operator/csv_scanner/header_value.hpp" namespace duckdb { +class InternalAppender; +class CSVFileScan; +class CSVRejectsTable; +struct ReadCSVData; //! Object that holds information on how many lines each csv batch read. - class LinesPerBoundary { public: LinesPerBoundary(); @@ -27,13 +30,6 @@ class LinesPerBoundary { idx_t boundary_idx = 0; idx_t lines_in_batch = 0; - - bool operator<(const LinesPerBoundary &other) const { - if (boundary_idx < other.boundary_idx) { - return true; - } - return lines_in_batch < other.lines_in_batch; - } }; enum CSVErrorType : uint8_t { @@ -63,8 +59,8 @@ class CSVError { idx_t column_idx, string &csv_row, LinesPerBoundary error_info, idx_t row_byte_position, optional_idx byte_position, LogicalTypeId type, const string ¤t_path); //! Produces error for when the line size exceeds the maximum line size option - static CSVError LineSizeError(const CSVReaderOptions &options, idx_t actual_size, LinesPerBoundary error_info, - string &csv_row, idx_t byte_position, const string ¤t_path); + static CSVError LineSizeError(const CSVReaderOptions &options, LinesPerBoundary error_info, string &csv_row, + idx_t byte_position, const string ¤t_path); //! Produces error for when the state machine reaches an invalid state static CSVError InvalidState(const CSVReaderOptions &options, idx_t current_column, LinesPerBoundary error_info, string &csv_row, idx_t row_byte_position, optional_idx byte_position, @@ -121,26 +117,27 @@ class CSVErrorHandler { public: explicit CSVErrorHandler(bool ignore_errors = false); //! Throws the error - void Error(CSVError csv_error, bool force_error = false); + void Error(const CSVError &csv_error, bool force_error = false); //! If we have a cached error, and we can now error, we error. void ErrorIfNeeded(); + //! Throws an error if a given type exists + void ErrorIfTypeExists(CSVErrorType error_type); //! Inserts a finished error info void Insert(idx_t boundary_idx, idx_t rows); idx_t GetLine(const LinesPerBoundary &error_info); void NewMaxLineSize(idx_t scan_line_size); //! Returns true if there are any errors bool AnyErrors(); - //! Set of errors - map> errors; + bool HasError(CSVErrorType error_type); + idx_t GetMaxLineLength(); - idx_t GetMaxLineLength() const { - return max_line_length; - } - void DontPrintErrorLine() { - print_line = false; - } + void DontPrintErrorLine(); void SetIgnoreErrors(bool ignore_errors); + idx_t GetSize(); + + void FillRejectsTable(InternalAppender &errors_appender, idx_t file_idx, idx_t scan_idx, const CSVFileScan &file, + CSVRejectsTable &rejects, const ReadCSVData &bind_data, idx_t limit); private: //! Private methods should always be locked by parent method. @@ -159,6 +156,8 @@ class CSVErrorHandler { idx_t max_line_length = 0; bool ignore_errors = false; bool print_line = true; + //! Set of errors + vector errors; }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_reader_options.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_reader_options.hpp index 0fc506659..4e0ee86fd 100644 --- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_reader_options.hpp +++ b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_reader_options.hpp @@ -87,7 +87,8 @@ struct CSVReaderOptions { //===--------------------------------------------------------------------===// //! Maximum CSV line size: specified because if we reach this amount, we likely have wrong delimiters (default: 2MB) //! note that this is the guaranteed line length that will succeed, longer lines may be accepted if slightly above - idx_t maximum_line_size = 2097152; + static constexpr idx_t max_line_size_default = 2000000; + CSVOption maximum_line_size = max_line_size_default; //! Whether header names shall be normalized bool normalize_names = false; //! True, if column with that index must skip null check @@ -108,7 +109,7 @@ struct CSVReaderOptions { //! Multi-file reader options MultiFileReaderOptions file_options; //! Buffer Size (Parallel Scan) - idx_t buffer_size = CSVBuffer::CSV_BUFFER_SIZE; + CSVOption buffer_size_option = CSVBuffer::ROWS_PER_BUFFER * max_line_size_default; //! Decimal separator when reading as numeric string decimal_separator = "."; //! Whether to pad rows that do not have enough columns with NULL values diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/scanner_boundary.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/scanner_boundary.hpp index 9f0d97820..da796d79e 100644 --- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/scanner_boundary.hpp +++ b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/scanner_boundary.hpp @@ -27,7 +27,7 @@ namespace duckdb { struct CSVBoundary { CSVBoundary(idx_t buffer_idx, idx_t buffer_pos, idx_t boundary_idx, idx_t end_pos); CSVBoundary(); - void Print(); + void Print() const; //! Start Buffer index of the file where we start scanning idx_t buffer_idx = 0; //! Start Buffer position of the buffer of the file where we start scanning @@ -53,10 +53,10 @@ struct CSVIterator { public: CSVIterator(); - void Print(); + void Print() const; //! Moves the boundary to the next one to be scanned, if there are no next boundaries, it returns False //! Otherwise, if there are boundaries, it returns True - bool Next(CSVBufferManager &buffer_manager); + bool Next(CSVBufferManager &buffer_manager, const CSVReaderOptions &reader_options); //! If boundary is set bool IsBoundarySet() const; @@ -67,16 +67,20 @@ struct CSVIterator { void SetCurrentPositionToBoundary(); - void SetCurrentBoundaryToPosition(bool single_threaded); + void SetCurrentBoundaryToPosition(bool single_threaded, const CSVReaderOptions &reader_options); void SetStart(idx_t pos); void SetEnd(idx_t pos); // Gets the current position for the file - idx_t GetGlobalCurrentPos(); + idx_t GetGlobalCurrentPos() const; - //! 8 MB TODO: Should benchmarks other values - static constexpr idx_t BYTES_PER_THREAD = 8000000; + //! Checks if we are done with this iterator + void CheckIfDone(); + + static idx_t BytesPerThread(const CSVReaderOptions &reader_options); + + static constexpr idx_t ROWS_PER_THREAD = 4; CSVPosition pos; diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/string_value_scanner.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/string_value_scanner.hpp index ad2250660..a2a3d5372 100644 --- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/string_value_scanner.hpp +++ b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/string_value_scanner.hpp @@ -96,7 +96,8 @@ class CurrentError { class LineError { public: - explicit LineError(bool ignore_errors_p) : is_error_in_line(false), ignore_errors(ignore_errors_p) {}; + explicit LineError(const idx_t scan_id_p, const bool ignore_errors_p) + : is_error_in_line(false), ignore_errors(ignore_errors_p), scan_id(scan_id_p) {}; //! We clear up our CurrentError Vector void Reset() { current_errors.clear(); @@ -136,10 +137,15 @@ class LineError { return !current_errors.empty(); } + idx_t Size() const { + return current_errors.size(); + } + private: vector current_errors; bool is_error_in_line; bool ignore_errors; + idx_t scan_id; }; struct ParseTypeInfo { @@ -159,13 +165,14 @@ struct ParseTypeInfo { uint8_t scale; uint8_t width; }; + class StringValueResult : public ScannerResult { public: StringValueResult(CSVStates &states, CSVStateMachine &state_machine, const shared_ptr &buffer_handle, Allocator &buffer_allocator, idx_t result_size_p, idx_t buffer_position, CSVErrorHandler &error_handler, CSVIterator &iterator, bool store_line_size, shared_ptr csv_file_scan, idx_t &lines_read, bool sniffing, - string path); + string path, idx_t scan_id); ~StringValueResult(); @@ -324,6 +331,8 @@ class StringValueScanner : public BaseScanner { ValidatorLine GetValidationLine(); const idx_t scanner_idx; + //! We use the max of idx_t to signify this is a line finder scanner. + static constexpr idx_t LINE_FINDER_ID = NumericLimits::Maximum(); //! Variable that manages buffer tracking shared_ptr buffer_tracker; diff --git a/src/duckdb/src/include/duckdb/storage/compression/dictionary/compression.hpp b/src/duckdb/src/include/duckdb/storage/compression/dictionary/compression.hpp index b0f29dc59..09f1f44bd 100644 --- a/src/duckdb/src/include/duckdb/storage/compression/dictionary/compression.hpp +++ b/src/duckdb/src/include/duckdb/storage/compression/dictionary/compression.hpp @@ -47,7 +47,6 @@ struct DictionaryCompressionCompressState : public DictionaryCompressionState { data_ptr_t current_end_ptr; // Buffers and map for current segment - StringHeap heap; string_map_t current_string_map; vector index_buffer; vector selection_buffer; diff --git a/src/duckdb/src/planner/binder/expression/bind_operator_expression.cpp b/src/duckdb/src/planner/binder/expression/bind_operator_expression.cpp index 81addd406..9326c8849 100644 --- a/src/duckdb/src/planner/binder/expression/bind_operator_expression.cpp +++ b/src/duckdb/src/planner/binder/expression/bind_operator_expression.cpp @@ -134,6 +134,9 @@ BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth) D_ASSERT(op.children[0]->GetExpressionClass() == ExpressionClass::BOUND_EXPRESSION); D_ASSERT(op.children[1]->GetExpressionClass() == ExpressionClass::BOUND_EXPRESSION); auto &extract_exp = BoundExpression::GetExpression(*op.children[0]); + if (extract_exp->HasParameter() || extract_exp->return_type.id() == LogicalTypeId::UNKNOWN) { + throw ParameterNotResolvedException(); + } auto &name_exp = BoundExpression::GetExpression(*op.children[1]); const auto &extract_expr_type = extract_exp->return_type; if (extract_expr_type.id() != LogicalTypeId::STRUCT && extract_expr_type.id() != LogicalTypeId::UNION && diff --git a/src/duckdb/src/planner/binder/statement/bind_create.cpp b/src/duckdb/src/planner/binder/statement/bind_create.cpp index 495a687e6..8d53446fc 100644 --- a/src/duckdb/src/planner/binder/statement/bind_create.cpp +++ b/src/duckdb/src/planner/binder/statement/bind_create.cpp @@ -196,7 +196,7 @@ SchemaCatalogEntry &Binder::BindCreateFunctionInfo(CreateInfo &info) { if (param.IsQualified()) { throw BinderException("Invalid parameter name '%s': must be unqualified", param.ToString()); } - dummy_types.emplace_back(LogicalType::SQLNULL); + dummy_types.emplace_back(LogicalType::UNKNOWN); dummy_names.push_back(param.GetColumnName()); } // default parameters diff --git a/src/duckdb/src/storage/arena_allocator.cpp b/src/duckdb/src/storage/arena_allocator.cpp index a67eeb286..000444f75 100644 --- a/src/duckdb/src/storage/arena_allocator.cpp +++ b/src/duckdb/src/storage/arena_allocator.cpp @@ -107,12 +107,13 @@ data_ptr_t ArenaAllocator::Reallocate(data_ptr_t pointer, idx_t old_size, idx_t return pointer; } - auto head_ptr = head->data.get() + head->current_position; + const auto head_ptr = head->data.get() + head->current_position - old_size; + int64_t current_position = NumericCast(head->current_position); int64_t diff = NumericCast(size) - NumericCast(old_size); - if (pointer == head_ptr && (size < old_size || NumericCast(head->current_position) + diff <= - NumericCast(head->maximum_size))) { + if (pointer == head_ptr && + (size < old_size || current_position + diff <= NumericCast(head->maximum_size))) { // passed pointer is the head pointer, and the diff fits on the current chunk - head->current_position += NumericCast(diff); + head->current_position = NumericCast(current_position + diff); return pointer; } else { // allocate new memory diff --git a/src/duckdb/src/storage/compression/dictionary/compression.cpp b/src/duckdb/src/storage/compression/dictionary/compression.cpp index 064697fc7..64a3db402 100644 --- a/src/duckdb/src/storage/compression/dictionary/compression.cpp +++ b/src/duckdb/src/storage/compression/dictionary/compression.cpp @@ -6,8 +6,7 @@ namespace duckdb { DictionaryCompressionCompressState::DictionaryCompressionCompressState(ColumnDataCheckpointData &checkpoint_data_p, const CompressionInfo &info) : DictionaryCompressionState(info), checkpoint_data(checkpoint_data_p), - function(checkpoint_data.GetCompressionFunction(CompressionType::COMPRESSION_DICTIONARY)), - heap(BufferAllocator::Get(checkpoint_data.GetDatabase())) { + function(checkpoint_data.GetCompressionFunction(CompressionType::COMPRESSION_DICTIONARY)) { CreateEmptySegment(checkpoint_data.GetRowGroup().start); } @@ -72,7 +71,9 @@ void DictionaryCompressionCompressState::AddNewString(string_t str) { if (str.IsInlined()) { current_string_map.insert({str, index_buffer.size() - 1}); } else { - current_string_map.insert({heap.AddBlob(str), index_buffer.size() - 1}); + string_t dictionary_string((const char *)dict_pos, UnsafeNumericCast(str.GetSize())); // NOLINT + D_ASSERT(!dictionary_string.IsInlined()); + current_string_map.insert({dictionary_string, index_buffer.size() - 1}); } DictionaryCompression::SetDictionary(*current_segment, current_handle, current_dictionary); diff --git a/src/duckdb/src/storage/serialization/serialize_nodes.cpp b/src/duckdb/src/storage/serialization/serialize_nodes.cpp index 59fc2681d..6c0bc4ab1 100644 --- a/src/duckdb/src/storage/serialization/serialize_nodes.cpp +++ b/src/duckdb/src/storage/serialization/serialize_nodes.cpp @@ -174,7 +174,7 @@ void CSVReaderOptions::Serialize(Serializer &serializer) const { serializer.WritePropertyWithDefault>(102, "null_str", null_str); serializer.WriteProperty(103, "compression", compression); serializer.WritePropertyWithDefault(104, "allow_quoted_nulls", allow_quoted_nulls); - serializer.WritePropertyWithDefault(105, "maximum_line_size", maximum_line_size); + serializer.WriteProperty>(105, "maximum_line_size", maximum_line_size); serializer.WritePropertyWithDefault(106, "normalize_names", normalize_names); serializer.WritePropertyWithDefault>(107, "force_not_null", force_not_null); serializer.WritePropertyWithDefault(108, "all_varchar", all_varchar); @@ -183,7 +183,7 @@ void CSVReaderOptions::Serialize(Serializer &serializer) const { serializer.WritePropertyWithDefault(111, "file_path", file_path); serializer.WritePropertyWithDefault(112, "decimal_separator", decimal_separator); serializer.WritePropertyWithDefault(113, "null_padding", null_padding); - serializer.WritePropertyWithDefault(114, "buffer_size", buffer_size); + /* [Deleted] (idx_t) "buffer_size" */ serializer.WriteProperty(115, "file_options", file_options); serializer.WritePropertyWithDefault>(116, "force_quote", force_quote); serializer.WritePropertyWithDefault(117, "rejects_table_name", rejects_table_name, "reject_errors"); @@ -212,6 +212,7 @@ void CSVReaderOptions::Serialize(Serializer &serializer) const { serializer.WriteProperty>(140, "rfc_4180", dialect_options.state_machine_options.rfc_4180); serializer.WriteProperty>(141, "multi_byte_delimiter", GetMultiByteDelimiter()); serializer.WritePropertyWithDefault(142, "multi_file_reader", multi_file_reader); + serializer.WriteProperty>(143, "buffer_size_option", buffer_size_option); } CSVReaderOptions CSVReaderOptions::Deserialize(Deserializer &deserializer) { @@ -220,7 +221,7 @@ CSVReaderOptions CSVReaderOptions::Deserialize(Deserializer &deserializer) { auto null_str = deserializer.ReadPropertyWithDefault>(102, "null_str"); auto compression = deserializer.ReadProperty(103, "compression"); auto allow_quoted_nulls = deserializer.ReadPropertyWithDefault(104, "allow_quoted_nulls"); - auto maximum_line_size = deserializer.ReadPropertyWithDefault(105, "maximum_line_size"); + auto maximum_line_size = deserializer.ReadProperty>(105, "maximum_line_size"); auto normalize_names = deserializer.ReadPropertyWithDefault(106, "normalize_names"); auto force_not_null = deserializer.ReadPropertyWithDefault>(107, "force_not_null"); auto all_varchar = deserializer.ReadPropertyWithDefault(108, "all_varchar"); @@ -229,7 +230,7 @@ CSVReaderOptions CSVReaderOptions::Deserialize(Deserializer &deserializer) { auto file_path = deserializer.ReadPropertyWithDefault(111, "file_path"); auto decimal_separator = deserializer.ReadPropertyWithDefault(112, "decimal_separator"); auto null_padding = deserializer.ReadPropertyWithDefault(113, "null_padding"); - auto buffer_size = deserializer.ReadPropertyWithDefault(114, "buffer_size"); + deserializer.ReadDeletedProperty(114, "buffer_size"); auto file_options = deserializer.ReadProperty(115, "file_options"); auto force_quote = deserializer.ReadPropertyWithDefault>(116, "force_quote"); auto rejects_table_name = deserializer.ReadPropertyWithExplicitDefault(117, "rejects_table_name", "reject_errors"); @@ -272,7 +273,6 @@ CSVReaderOptions CSVReaderOptions::Deserialize(Deserializer &deserializer) { result.file_path = std::move(file_path); result.decimal_separator = std::move(decimal_separator); result.null_padding = null_padding; - result.buffer_size = buffer_size; result.file_options = file_options; result.force_quote = std::move(force_quote); result.rejects_table_name = std::move(rejects_table_name); @@ -297,6 +297,7 @@ CSVReaderOptions CSVReaderOptions::Deserialize(Deserializer &deserializer) { result.encoding = std::move(encoding); result.dialect_options.state_machine_options.rfc_4180 = dialect_options_state_machine_options_rfc_4180; deserializer.ReadPropertyWithDefault(142, "multi_file_reader", result.multi_file_reader); + deserializer.ReadProperty>(143, "buffer_size_option", result.buffer_size_option); return result; } From 5adc767b6f1904c12b71f17e1b3949a5d9889ffe Mon Sep 17 00:00:00 2001 From: DuckDB Labs GitHub Bot Date: Fri, 10 Jan 2025 00:34:45 +0000 Subject: [PATCH 08/16] Update vendored DuckDB sources to 3be11b40 --- .../core_functions/scalar/date/epoch.cpp | 2 +- .../core_functions/scalar/date/make_date.cpp | 4 + .../scalar/list/list_reduce.cpp | 2 +- src/duckdb/extension/icu/icu-dateadd.cpp | 7 +- src/duckdb/extension/icu/icu-datefunc.cpp | 4 +- src/duckdb/extension/icu/icu-makedate.cpp | 9 +- src/duckdb/extension/icu/icu-strptime.cpp | 10 +- .../extension/icu/include/icu-datefunc.hpp | 2 +- .../extension/json/include/json_scan.hpp | 47 +++++- .../extension/json/include/json_structure.hpp | 3 +- .../json/json_functions/json_structure.cpp | 32 ++-- .../json/json_functions/read_json.cpp | 106 ++++++++---- src/duckdb/extension/json/json_scan.cpp | 2 +- src/duckdb/src/common/enum_util.cpp | 51 +++++- .../src/common/enums/compression_type.cpp | 4 + src/duckdb/src/common/file_system.cpp | 8 +- src/duckdb/src/common/local_file_system.cpp | 154 ++++++++++++++---- .../src/common/operator/cast_operators.cpp | 33 ++-- src/duckdb/src/common/random_engine.cpp | 18 +- src/duckdb/src/common/string_util.cpp | 9 +- src/duckdb/src/common/types/date.cpp | 64 +++++--- src/duckdb/src/common/types/timestamp.cpp | 80 +++++---- .../scanner/string_value_scanner.cpp | 5 +- .../csv_scanner/sniffer/type_detection.cpp | 2 +- .../aggregate/distributive/first_last_any.cpp | 16 +- src/duckdb/src/function/cast/struct_cast.cpp | 1 + .../src/function/compression_config.cpp | 2 + .../src/function/table/arrow_conversion.cpp | 10 +- .../function/table/version/pragma_version.cpp | 6 +- .../window/window_aggregate_function.cpp | 127 ++++----------- .../src/function/window/window_aggregator.cpp | 9 +- .../window/window_constant_aggregator.cpp | 137 ++++++++++++---- .../window/window_custom_aggregator.cpp | 23 ++- .../window/window_distinct_aggregator.cpp | 16 +- .../src/function/window/window_executor.cpp | 11 ++ .../src/function/window/window_index_tree.cpp | 2 +- .../window/window_merge_sort_tree.cpp | 5 +- .../window/window_naive_aggregator.cpp | 133 ++++++++++++++- .../function/window/window_segment_tree.cpp | 17 +- src/duckdb/src/include/duckdb.h | 53 +++++- .../src/include/duckdb/common/enum_util.hpp | 16 ++ .../duckdb/common/enums/compression_type.hpp | 5 +- .../duckdb/common/local_file_system.hpp | 3 + .../src/include/duckdb/common/types/date.hpp | 13 +- .../include/duckdb/common/types/timestamp.hpp | 13 +- .../function/compression/compression.hpp | 5 + .../duckdb/function/compression_function.hpp | 6 + .../window/window_aggregate_function.hpp | 6 +- .../function/window/window_aggregator.hpp | 10 +- .../window/window_constant_aggregator.hpp | 5 +- .../window/window_custom_aggregator.hpp | 5 +- .../window/window_distinct_aggregator.hpp | 6 +- .../window/window_naive_aggregator.hpp | 10 +- .../function/window/window_segment_tree.hpp | 15 +- .../duckdb/main/capi/capi_internal.hpp | 9 +- .../duckdb/main/capi/extension_api.hpp | 10 ++ .../expression/bound_window_expression.hpp | 1 + .../expression_binder/index_binder.hpp | 2 + .../storage/compression/empty_validity.hpp | 100 ++++++++++++ .../duckdb/storage/table/column_data.hpp | 1 + .../table/column_data_checkpointer.hpp | 1 + src/duckdb/src/include/duckdb_extension.h | 24 ++- src/duckdb/src/main/capi/duckdb-c.cpp | 67 ++++++-- .../src/main/capi/replacement_scan-c.cpp | 2 +- src/duckdb/src/main/capi/threading-c.cpp | 8 +- src/duckdb/src/main/database.cpp | 1 + .../src/main/extension/extension_load.cpp | 6 +- .../expression/transform_function.cpp | 2 +- .../expression/bound_window_expression.cpp | 12 +- .../expression_binder/index_binder.cpp | 33 ++-- .../compression/dictionary/decompression.cpp | 11 +- .../compression/dictionary_compression.cpp | 4 +- .../storage/compression/empty_validity.cpp | 15 ++ src/duckdb/src/storage/table/column_data.cpp | 10 ++ .../table/column_data_checkpointer.cpp | 35 +++- src/duckdb/third_party/httplib/httplib.hpp | 17 +- src/duckdb/third_party/skiplist/SkipList.h | 1 - src/duckdb/ub_src_storage_compression.cpp | 2 + 78 files changed, 1261 insertions(+), 457 deletions(-) create mode 100644 src/duckdb/src/include/duckdb/storage/compression/empty_validity.hpp create mode 100644 src/duckdb/src/storage/compression/empty_validity.cpp diff --git a/src/duckdb/extension/core_functions/scalar/date/epoch.cpp b/src/duckdb/extension/core_functions/scalar/date/epoch.cpp index c30530341..cda3232a4 100644 --- a/src/duckdb/extension/core_functions/scalar/date/epoch.cpp +++ b/src/duckdb/extension/core_functions/scalar/date/epoch.cpp @@ -11,7 +11,7 @@ struct EpochSecOperator { static RESULT_TYPE Operation(INPUT_TYPE sec) { int64_t result; if (!TryCast::Operation(sec * Interval::MICROS_PER_SEC, result)) { - throw ConversionException("Could not convert epoch seconds to TIMESTAMP WITH TIME ZONE"); + throw ConversionException("Epoch seconds out of range for TIMESTAMP WITH TIME ZONE"); } return timestamp_t(result); } diff --git a/src/duckdb/extension/core_functions/scalar/date/make_date.cpp b/src/duckdb/extension/core_functions/scalar/date/make_date.cpp index 71591a227..0fe00a920 100644 --- a/src/duckdb/extension/core_functions/scalar/date/make_date.cpp +++ b/src/duckdb/extension/core_functions/scalar/date/make_date.cpp @@ -103,6 +103,10 @@ struct MakeTimestampOperator { template static RESULT_TYPE Operation(T value) { + const auto result = RESULT_TYPE(value); + if (!Timestamp::IsFinite(result)) { + throw ConversionException("Timestamp microseconds out of range: %ld", value); + } return RESULT_TYPE(value); } }; 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 f8758515f..173b52699 100644 --- a/src/duckdb/extension/core_functions/scalar/list/list_reduce.cpp +++ b/src/duckdb/extension/core_functions/scalar/list/list_reduce.cpp @@ -101,7 +101,7 @@ static bool ExecuteReduce(idx_t loops, ReduceExecuteInfo &execute_info, LambdaFu } // create the index vector - Vector index_vector(Value::BIGINT(UnsafeNumericCast(loops + 1))); + Vector index_vector(Value::BIGINT(UnsafeNumericCast(loops + 2))); // slice the left and right slice execute_info.left_slice->Slice(*execute_info.left_slice, execute_info.left_sel, reduced_row_idx); diff --git a/src/duckdb/extension/icu/icu-dateadd.cpp b/src/duckdb/extension/icu/icu-dateadd.cpp index c6e1ece24..29b0cf73b 100644 --- a/src/duckdb/extension/icu/icu-dateadd.cpp +++ b/src/duckdb/extension/icu/icu-dateadd.cpp @@ -132,6 +132,9 @@ timestamp_t ICUCalendarSub::Operation(timestamp_t timestamp, interval_t interval template <> interval_t ICUCalendarSub::Operation(timestamp_t end_date, timestamp_t start_date, icu::Calendar *calendar) { + if (!Timestamp::IsFinite(end_date) || !Timestamp::IsFinite(start_date)) { + throw InvalidInputException("Cannot subtract infinite timestamps"); + } if (start_date > end_date) { auto negated = Operation(start_date, end_date, calendar); return {-negated.months, -negated.days, -negated.micros}; @@ -156,7 +159,7 @@ interval_t ICUCalendarSub::Operation(timestamp_t end_date, timestamp_t start_dat auto min_diff = SubtractField(calendar, UCAL_MINUTE, end_date); auto sec_diff = SubtractField(calendar, UCAL_SECOND, end_date); auto ms_diff = SubtractField(calendar, UCAL_MILLISECOND, end_date); - auto micros_diff = ms_diff * Interval::MICROS_PER_MSEC + (end_micros - start_micros); + auto micros_diff = UnsafeNumericCast(ms_diff * Interval::MICROS_PER_MSEC + (end_micros - start_micros)); result.micros = Time::FromTime(hour_diff, min_diff, sec_diff, micros_diff).micros; return result; @@ -188,7 +191,7 @@ interval_t ICUCalendarAge::Operation(timestamp_t end_date, timestamp_t start_dat auto min_diff = SubtractField(calendar, UCAL_MINUTE, end_date); auto sec_diff = SubtractField(calendar, UCAL_SECOND, end_date); auto ms_diff = SubtractField(calendar, UCAL_MILLISECOND, end_date); - auto micros_diff = ms_diff * Interval::MICROS_PER_MSEC + (end_micros - start_micros); + auto micros_diff = UnsafeNumericCast(ms_diff * Interval::MICROS_PER_MSEC + (end_micros - start_micros)); result.micros = Time::FromTime(hour_diff, min_diff, sec_diff, micros_diff).micros; return result; diff --git a/src/duckdb/extension/icu/icu-datefunc.cpp b/src/duckdb/extension/icu/icu-datefunc.cpp index b0202f8d9..995f594ce 100644 --- a/src/duckdb/extension/icu/icu-datefunc.cpp +++ b/src/duckdb/extension/icu/icu-datefunc.cpp @@ -117,7 +117,7 @@ bool ICUDateFunc::TryGetTime(icu::Calendar *calendar, uint64_t micros, timestamp timestamp_t ICUDateFunc::GetTime(icu::Calendar *calendar, uint64_t micros) { timestamp_t result; if (!TryGetTime(calendar, micros, result)) { - throw ConversionException("Unable to convert ICU date to timestamp"); + throw ConversionException("ICU date overflows timestamp range"); } return result; } @@ -148,7 +148,7 @@ int32_t ICUDateFunc::ExtractField(icu::Calendar *calendar, UCalendarDateFields f return result; } -int64_t ICUDateFunc::SubtractField(icu::Calendar *calendar, UCalendarDateFields field, timestamp_t end_date) { +int32_t ICUDateFunc::SubtractField(icu::Calendar *calendar, UCalendarDateFields field, timestamp_t end_date) { const int64_t millis = end_date.value / Interval::MICROS_PER_MSEC; const auto when = UDate(millis); UErrorCode status = U_ZERO_ERROR; diff --git a/src/duckdb/extension/icu/icu-makedate.cpp b/src/duckdb/extension/icu/icu-makedate.cpp index ce09476dd..ad092a155 100644 --- a/src/duckdb/extension/icu/icu-makedate.cpp +++ b/src/duckdb/extension/icu/icu-makedate.cpp @@ -94,8 +94,13 @@ struct ICUMakeTimestampTZFunc : public ICUDateFunc { template static void FromMicros(DataChunk &input, ExpressionState &state, Vector &result) { - UnaryExecutor::Execute(input.data[0], result, input.size(), - [&](T micros) { return timestamp_t(micros); }); + UnaryExecutor::Execute(input.data[0], result, input.size(), [&](T micros) { + const auto result = timestamp_t(micros); + if (!Timestamp::IsFinite(result)) { + throw ConversionException("Timestamp microseconds out of range: %ld", micros); + } + return result; + }); } template diff --git a/src/duckdb/extension/icu/icu-strptime.cpp b/src/duckdb/extension/icu/icu-strptime.cpp index 35ac05934..4e377e787 100644 --- a/src/duckdb/extension/icu/icu-strptime.cpp +++ b/src/duckdb/extension/icu/icu-strptime.cpp @@ -258,8 +258,14 @@ struct ICUStrptime : public ICUDateFunc { const auto len = input.GetSize(); string_t tz(nullptr, 0); bool has_offset = false; - if (!Timestamp::TryConvertTimestampTZ(str, len, result, has_offset, tz)) { - auto msg = Timestamp::ConversionError(string(str, len)); + auto success = Timestamp::TryConvertTimestampTZ(str, len, result, has_offset, tz); + if (success != TimestampCastResult::SUCCESS) { + string msg; + if (success == TimestampCastResult::ERROR_RANGE) { + msg = Timestamp::RangeError(string(str, len)); + } else { + msg = Timestamp::FormatError(string(str, len)); + } HandleCastError::AssignError(msg, parameters); mask.SetInvalid(idx); } else if (!has_offset) { diff --git a/src/duckdb/extension/icu/include/icu-datefunc.hpp b/src/duckdb/extension/icu/include/icu-datefunc.hpp index 5654b2603..2c837f2f1 100644 --- a/src/duckdb/extension/icu/include/icu-datefunc.hpp +++ b/src/duckdb/extension/icu/include/icu-datefunc.hpp @@ -62,7 +62,7 @@ struct ICUDateFunc { //! Extracts the field from the calendar static int32_t ExtractField(icu::Calendar *calendar, UCalendarDateFields field); //! Subtracts the field of the given date from the calendar - static int64_t SubtractField(icu::Calendar *calendar, UCalendarDateFields field, timestamp_t end_date); + static int32_t SubtractField(icu::Calendar *calendar, UCalendarDateFields field, timestamp_t end_date); //! Adds the timestamp and the interval using the calendar static timestamp_t Add(icu::Calendar *calendar, timestamp_t timestamp, interval_t interval); //! Subtracts the interval from the timestamp using the calendar diff --git a/src/duckdb/extension/json/include/json_scan.hpp b/src/duckdb/extension/json/include/json_scan.hpp index 61439b612..4fd7bc0a0 100644 --- a/src/duckdb/extension/json/include/json_scan.hpp +++ b/src/duckdb/extension/json/include/json_scan.hpp @@ -41,6 +41,19 @@ struct JSONString { }; struct DateFormatMap { +public: + DateFormatMap() { + } + + DateFormatMap(DateFormatMap &&other) noexcept { + candidate_formats = other.candidate_formats; + } + + DateFormatMap &operator=(DateFormatMap &&other) noexcept { + candidate_formats = other.candidate_formats; + return *this; + } + public: void Initialize(const type_id_map_t> &format_templates) { for (const auto &entry : format_templates) { @@ -51,6 +64,12 @@ struct DateFormatMap { } } + DateFormatMap Copy() const { + DateFormatMap result; + result.candidate_formats = candidate_formats; + return result; + } + void AddFormat(LogicalTypeId type, const string &format_string) { auto &formats = candidate_formats[type]; formats.emplace_back(); @@ -59,25 +78,47 @@ struct DateFormatMap { } bool HasFormats(LogicalTypeId type) const { + lock_guard guard(lock); return candidate_formats.find(type) != candidate_formats.end(); } - vector &GetCandidateFormats(LogicalTypeId type) { - D_ASSERT(HasFormats(type)); - return candidate_formats[type]; + idx_t NumberOfFormats(LogicalTypeId type) { + lock_guard guard(lock); + return candidate_formats[type].size(); + } + + bool GetFormatAtIndex(LogicalTypeId type, idx_t index, StrpTimeFormat &format) { + lock_guard guard(lock); + auto &formats = candidate_formats[type]; + if (index >= formats.size()) { + return false; + } + format = formats[index]; + return true; + } + + void ShrinkFormatsToSize(LogicalTypeId type, idx_t size) { + lock_guard guard(lock); + auto &formats = candidate_formats[type]; + while (formats.size() > size) { + formats.pop_back(); + } } StrpTimeFormat &GetFormat(LogicalTypeId type) { + lock_guard guard(lock); D_ASSERT(candidate_formats.find(type) != candidate_formats.end()); return candidate_formats.find(type)->second.back(); } const StrpTimeFormat &GetFormat(LogicalTypeId type) const { + lock_guard guard(lock); D_ASSERT(candidate_formats.find(type) != candidate_formats.end()); return candidate_formats.find(type)->second.back(); } private: + mutable mutex lock; type_id_map_t> candidate_formats; }; diff --git a/src/duckdb/extension/json/include/json_structure.hpp b/src/duckdb/extension/json/include/json_structure.hpp index 3102dc903..baf06520d 100644 --- a/src/duckdb/extension/json/include/json_structure.hpp +++ b/src/duckdb/extension/json/include/json_structure.hpp @@ -45,7 +45,7 @@ struct JSONStructureNode { DateFormatMap &date_format_map); void EliminateCandidateTypes(idx_t vec_count, Vector &string_vector, DateFormatMap &date_format_map); bool EliminateCandidateFormats(idx_t vec_count, Vector &string_vector, const Vector &result_vector, - vector &formats); + DateFormatMap &date_format_map); public: unique_ptr key; @@ -84,6 +84,7 @@ struct JSONStructureDescription { struct JSONStructure { public: static void ExtractStructure(yyjson_val *val, JSONStructureNode &node, bool ignore_errors); + static void MergeNodes(JSONStructureNode &merged, const JSONStructureNode &node); static LogicalType StructureToType(ClientContext &context, const JSONStructureNode &node, idx_t max_depth, double field_appearance_threshold, idx_t map_inference_threshold, idx_t depth = 0, const LogicalType &null_type = LogicalType::JSON()); diff --git a/src/duckdb/extension/json/json_functions/json_structure.cpp b/src/duckdb/extension/json/json_functions/json_structure.cpp index 361ac773f..fbc71366e 100644 --- a/src/duckdb/extension/json/json_functions/json_structure.cpp +++ b/src/duckdb/extension/json/json_functions/json_structure.cpp @@ -261,8 +261,7 @@ void JSONStructureNode::EliminateCandidateTypes(const idx_t vec_count, Vector &s const auto type = candidate_types.back(); Vector result_vector(type, vec_count); if (date_format_map.HasFormats(type)) { - auto &formats = date_format_map.GetCandidateFormats(type); - if (EliminateCandidateFormats(vec_count, string_vector, result_vector, formats)) { + if (EliminateCandidateFormats(vec_count, string_vector, result_vector, date_format_map)) { return; } else { candidate_types.pop_back(); @@ -304,12 +303,17 @@ bool TryParse(Vector &string_vector, StrpTimeFormat &format, const idx_t count) } bool JSONStructureNode::EliminateCandidateFormats(const idx_t vec_count, Vector &string_vector, - const Vector &result_vector, vector &formats) { + const Vector &result_vector, DateFormatMap &date_format_map) { D_ASSERT(descriptions.size() == 1 && descriptions[0].type == LogicalTypeId::VARCHAR); + const auto type = result_vector.GetType().id(); - for (idx_t i = formats.size(); i != 0; i--) { - const idx_t actual_index = i - 1; - auto &format = formats[actual_index]; + auto i = date_format_map.NumberOfFormats(type); + for (; i != 0; i--) { + StrpTimeFormat format; + if (!date_format_map.GetFormatAtIndex(type, i - 1, format)) { + continue; + } + bool success; switch (type) { case LogicalTypeId::DATE: @@ -321,13 +325,13 @@ bool JSONStructureNode::EliminateCandidateFormats(const idx_t vec_count, Vector default: throw InternalException("No date/timestamp formats for %s", EnumUtil::ToString(type)); } + if (success) { - while (formats.size() > i) { - formats.pop_back(); - } + date_format_map.ShrinkFormatsToSize(type, i); return true; } } + return false; } @@ -531,14 +535,12 @@ static LogicalType StructureToTypeArray(ClientContext &context, const JSONStruct depth + 1, null_type)); } -static void MergeNodes(JSONStructureNode &merged, const JSONStructureNode &node); - static void MergeNodeArray(JSONStructureNode &merged, const JSONStructureDescription &child_desc) { D_ASSERT(child_desc.type == LogicalTypeId::LIST); auto &merged_desc = merged.GetOrCreateDescription(LogicalTypeId::LIST); auto &merged_child = merged_desc.GetOrCreateChild(); for (auto &list_child : child_desc.children) { - MergeNodes(merged_child, list_child); + JSONStructure::MergeNodes(merged_child, list_child); } } @@ -548,7 +550,7 @@ static void MergeNodeObject(JSONStructureNode &merged, const JSONStructureDescri for (auto &struct_child : child_desc.children) { const auto &struct_child_key = *struct_child.key; auto &merged_child = merged_desc.GetOrCreateChild(struct_child_key.c_str(), struct_child_key.length()); - MergeNodes(merged_child, struct_child); + JSONStructure::MergeNodes(merged_child, struct_child); } } @@ -570,7 +572,7 @@ static void MergeNodeVal(JSONStructureNode &merged, const JSONStructureDescripti merged.initialized = true; } -static void MergeNodes(JSONStructureNode &merged, const JSONStructureNode &node) { +void JSONStructure::MergeNodes(JSONStructureNode &merged, const JSONStructureNode &node) { merged.count += node.count; merged.null_count += node.null_count; for (const auto &child_desc : node.descriptions) { @@ -695,7 +697,7 @@ static LogicalType GetMergedType(ClientContext &context, const JSONStructureNode auto &desc = node.descriptions[0]; JSONStructureNode merged; for (const auto &child : desc.children) { - MergeNodes(merged, child); + JSONStructure::MergeNodes(merged, child); } return JSONStructure::StructureToType(context, merged, max_depth, field_appearance_threshold, map_inference_threshold, depth + 1, null_type); diff --git a/src/duckdb/extension/json/json_functions/read_json.cpp b/src/duckdb/extension/json/json_functions/read_json.cpp index 78c1b4379..6ee8fa237 100644 --- a/src/duckdb/extension/json/json_functions/read_json.cpp +++ b/src/duckdb/extension/json/json_functions/read_json.cpp @@ -4,6 +4,7 @@ #include "json_scan.hpp" #include "json_structure.hpp" #include "json_transform.hpp" +#include "duckdb/parallel/task_executor.hpp" namespace duckdb { @@ -36,20 +37,18 @@ static inline LogicalType RemoveDuplicateStructKeys(const LogicalType &type, con } } -void JSONScan::AutoDetect(ClientContext &context, JSONScanData &bind_data, vector &return_types, - vector &names) { - // Change scan type during detection - bind_data.type = JSONScanType::SAMPLE; - - // These are used across files (if union_by_name) - JSONStructureNode node; - ArenaAllocator allocator(BufferAllocator::Get(context)); - Vector string_vector(LogicalType::VARCHAR); +class JSONSchemaTask : public BaseExecutorTask { +public: + JSONSchemaTask(TaskExecutor &executor, ClientContext &context_p, JSONScanData &bind_data_p, + JSONStructureNode &node_p, const idx_t file_idx_start_p, const idx_t file_idx_end_p) + : BaseExecutorTask(executor), context(context_p), bind_data(bind_data_p), node(node_p), + file_idx_start(file_idx_start_p), file_idx_end(file_idx_end_p), allocator(BufferAllocator::Get(context)), + string_vector(LogicalType::VARCHAR) { + } - // Loop through the files (if union_by_name, else sample up to sample_size rows or maximum_sample_files files) - idx_t remaining = bind_data.sample_size; - for (idx_t file_idx = 0; file_idx < bind_data.files.size(); file_idx++) { - // Create global/local state and place the reader in the right field + static idx_t ExecuteInternal(ClientContext &context, JSONScanData &bind_data, JSONStructureNode &node, + const idx_t file_idx, ArenaAllocator &allocator, Vector &string_vector, + idx_t remaining) { JSONScanGlobalState gstate(context, bind_data); JSONScanLocalState lstate(context, gstate); if (file_idx == 0) { @@ -61,12 +60,12 @@ void JSONScan::AutoDetect(ClientContext &context, JSONScanData &bind_data, vecto // Read and detect schema while (remaining != 0) { allocator.Reset(); - auto read_count = lstate.ReadNext(gstate); + const auto read_count = lstate.ReadNext(gstate); if (read_count == 0) { break; } - idx_t next = MinValue(read_count, remaining); + const auto next = MinValue(read_count, remaining); for (idx_t i = 0; i < next; i++) { const auto &val = lstate.values[i]; if (val) { @@ -85,13 +84,62 @@ void JSONScan::AutoDetect(ClientContext &context, JSONScanData &bind_data, vecto bind_data.avg_tuple_size = lstate.total_read_size / lstate.total_tuple_count; } - // Close the file and stop detection if not union_by_name - if (bind_data.options.file_options.union_by_name) { - // When union_by_name=true we sample sample_size per file - remaining = bind_data.sample_size; - } else if (remaining == 0 || file_idx == bind_data.maximum_sample_files - 1) { - // When union_by_name=false, we sample sample_size in total (across the first maximum_sample_files files) - break; + return remaining; + } + + void ExecuteTask() override { + for (idx_t file_idx = file_idx_start; file_idx < file_idx_end; file_idx++) { + ExecuteInternal(context, bind_data, node, file_idx, allocator, string_vector, bind_data.sample_size); + } + } + +private: + ClientContext &context; + JSONScanData &bind_data; + JSONStructureNode &node; + const idx_t file_idx_start; + const idx_t file_idx_end; + + ArenaAllocator allocator; + Vector string_vector; +}; + +void JSONScan::AutoDetect(ClientContext &context, JSONScanData &bind_data, vector &return_types, + vector &names) { + // Change scan type during detection + bind_data.type = JSONScanType::SAMPLE; + + JSONStructureNode node; + if (bind_data.options.file_options.union_by_name) { + const auto num_threads = NumericCast(TaskScheduler::GetScheduler(context).NumberOfThreads()); + const auto files_per_task = (bind_data.files.size() + num_threads - 1) / num_threads; + const auto num_tasks = bind_data.files.size() / files_per_task; + vector task_nodes(num_tasks); + + // Same idea as in union_by_name.hpp + TaskExecutor executor(context); + for (idx_t task_idx = 0; task_idx < num_tasks; task_idx++) { + const auto file_idx_start = task_idx * files_per_task; + auto task = make_uniq(executor, context, bind_data, task_nodes[task_idx], file_idx_start, + file_idx_start + files_per_task); + executor.ScheduleTask(std::move(task)); + } + executor.WorkOnTasks(); + + // Merge task nodes into one + for (auto &task_node : task_nodes) { + JSONStructure::MergeNodes(node, task_node); + } + } else { + ArenaAllocator allocator(BufferAllocator::Get(context)); + Vector string_vector(LogicalType::VARCHAR); + idx_t remaining = bind_data.sample_size; + for (idx_t file_idx = 0; file_idx < bind_data.files.size(); file_idx++) { + remaining = JSONSchemaTask::ExecuteInternal(context, bind_data, node, file_idx, allocator, string_vector, + remaining); + if (remaining == 0 || file_idx == bind_data.maximum_sample_files - 1) { + break; // We sample sample_size in total (across the first maximum_sample_files files) + } } } @@ -306,14 +354,14 @@ unique_ptr ReadJSONBind(ClientContext &context, TableFunctionBindI // JSON may contain columns such as "id" and "Id", which are duplicates for us due to case-insensitivity // We rename them so we can parse the file anyway. Note that we can't change bind_data->names, // because the JSON reader gets columns by exact name, not position - case_insensitive_map_t name_count_map; - for (auto &name : names) { - auto it = name_count_map.find(name); - if (it == name_count_map.end()) { - name_count_map[name] = 1; - } else { - name = StringUtil::Format("%s_%llu", name, it->second++); + case_insensitive_map_t name_collision_count; + for (auto &col_name : names) { + // Taken from CSV header_detection.cpp + while (name_collision_count.find(col_name) != name_collision_count.end()) { + name_collision_count[col_name] += 1; + col_name = col_name + "_" + to_string(name_collision_count[col_name]); } + name_collision_count[col_name] = 0; } } diff --git a/src/duckdb/extension/json/json_scan.cpp b/src/duckdb/extension/json/json_scan.cpp index bd0a34e03..d038885d9 100644 --- a/src/duckdb/extension/json/json_scan.cpp +++ b/src/duckdb/extension/json/json_scan.cpp @@ -249,7 +249,7 @@ unique_ptr JSONLocalTableFunctionState::Init(ExecutionC auto result = make_uniq(context.client, gstate.state); // Copy the transform options / date format map because we need to do thread-local stuff - result->state.date_format_map = gstate.state.bind_data.date_format_map; + result->state.date_format_map = gstate.state.bind_data.date_format_map.Copy(); result->state.transform_options = gstate.state.transform_options; result->state.transform_options.date_format_map = &result->state.date_format_map; diff --git a/src/duckdb/src/common/enum_util.cpp b/src/duckdb/src/common/enum_util.cpp index 23d9c6e27..1fd91919b 100644 --- a/src/duckdb/src/common/enum_util.cpp +++ b/src/duckdb/src/common/enum_util.cpp @@ -73,6 +73,7 @@ #include "duckdb/common/types/column/column_data_scan_states.hpp" #include "duckdb/common/types/column/partitioned_column_data.hpp" #include "duckdb/common/types/conflict_manager.hpp" +#include "duckdb/common/types/date.hpp" #include "duckdb/common/types/hyperloglog.hpp" #include "duckdb/common/types/row/partitioned_tuple_data.hpp" #include "duckdb/common/types/row/tuple_data_states.hpp" @@ -86,6 +87,7 @@ #include "duckdb/execution/operator/csv_scanner/quote_rules.hpp" #include "duckdb/execution/reservoir_sample.hpp" #include "duckdb/function/aggregate_state.hpp" +#include "duckdb/function/compression_function.hpp" #include "duckdb/function/copy_function.hpp" #include "duckdb/function/function.hpp" #include "duckdb/function/macro_function.hpp" @@ -859,6 +861,7 @@ const StringUtil::EnumStringLiteral *GetCompressionTypeValues() { { 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_COUNT), "COMPRESSION_COUNT" } }; return values; @@ -866,12 +869,30 @@ const StringUtil::EnumStringLiteral *GetCompressionTypeValues() { template<> const char* EnumUtil::ToChars(CompressionType value) { - return StringUtil::EnumToString(GetCompressionTypeValues(), 15, "CompressionType", static_cast(value)); + return StringUtil::EnumToString(GetCompressionTypeValues(), 16, "CompressionType", static_cast(value)); } template<> CompressionType EnumUtil::FromString(const char *value) { - return static_cast(StringUtil::StringToEnum(GetCompressionTypeValues(), 15, "CompressionType", value)); + return static_cast(StringUtil::StringToEnum(GetCompressionTypeValues(), 16, "CompressionType", value)); +} + +const StringUtil::EnumStringLiteral *GetCompressionValidityValues() { + static constexpr StringUtil::EnumStringLiteral values[] { + { static_cast(CompressionValidity::REQUIRES_VALIDITY), "REQUIRES_VALIDITY" }, + { static_cast(CompressionValidity::NO_VALIDITY_REQUIRED), "NO_VALIDITY_REQUIRED" } + }; + return values; +} + +template<> +const char* EnumUtil::ToChars(CompressionValidity value) { + return StringUtil::EnumToString(GetCompressionValidityValues(), 2, "CompressionValidity", static_cast(value)); +} + +template<> +CompressionValidity EnumUtil::FromString(const char *value) { + return static_cast(StringUtil::StringToEnum(GetCompressionValidityValues(), 2, "CompressionValidity", value)); } const StringUtil::EnumStringLiteral *GetConflictManagerModeValues() { @@ -989,6 +1010,25 @@ DataFileType EnumUtil::FromString(const char *value) { return static_cast(StringUtil::StringToEnum(GetDataFileTypeValues(), 4, "DataFileType", value)); } +const StringUtil::EnumStringLiteral *GetDateCastResultValues() { + static constexpr StringUtil::EnumStringLiteral values[] { + { static_cast(DateCastResult::SUCCESS), "SUCCESS" }, + { static_cast(DateCastResult::ERROR_INCORRECT_FORMAT), "ERROR_INCORRECT_FORMAT" }, + { static_cast(DateCastResult::ERROR_RANGE), "ERROR_RANGE" } + }; + return values; +} + +template<> +const char* EnumUtil::ToChars(DateCastResult value) { + return StringUtil::EnumToString(GetDateCastResultValues(), 3, "DateCastResult", static_cast(value)); +} + +template<> +DateCastResult EnumUtil::FromString(const char *value) { + return static_cast(StringUtil::StringToEnum(GetDateCastResultValues(), 3, "DateCastResult", value)); +} + const StringUtil::EnumStringLiteral *GetDatePartSpecifierValues() { static constexpr StringUtil::EnumStringLiteral values[] { { static_cast(DatePartSpecifier::YEAR), "YEAR" }, @@ -3860,19 +3900,20 @@ const StringUtil::EnumStringLiteral *GetTimestampCastResultValues() { static constexpr StringUtil::EnumStringLiteral values[] { { static_cast(TimestampCastResult::SUCCESS), "SUCCESS" }, { static_cast(TimestampCastResult::ERROR_INCORRECT_FORMAT), "ERROR_INCORRECT_FORMAT" }, - { static_cast(TimestampCastResult::ERROR_NON_UTC_TIMEZONE), "ERROR_NON_UTC_TIMEZONE" } + { static_cast(TimestampCastResult::ERROR_NON_UTC_TIMEZONE), "ERROR_NON_UTC_TIMEZONE" }, + { static_cast(TimestampCastResult::ERROR_RANGE), "ERROR_RANGE" } }; return values; } template<> const char* EnumUtil::ToChars(TimestampCastResult value) { - return StringUtil::EnumToString(GetTimestampCastResultValues(), 3, "TimestampCastResult", static_cast(value)); + return StringUtil::EnumToString(GetTimestampCastResultValues(), 4, "TimestampCastResult", static_cast(value)); } template<> TimestampCastResult EnumUtil::FromString(const char *value) { - return static_cast(StringUtil::StringToEnum(GetTimestampCastResultValues(), 3, "TimestampCastResult", value)); + return static_cast(StringUtil::StringToEnum(GetTimestampCastResultValues(), 4, "TimestampCastResult", value)); } const StringUtil::EnumStringLiteral *GetTransactionModifierTypeValues() { diff --git a/src/duckdb/src/common/enums/compression_type.cpp b/src/duckdb/src/common/enums/compression_type.cpp index b0528a7dd..3bc66fe08 100644 --- a/src/duckdb/src/common/enums/compression_type.cpp +++ b/src/duckdb/src/common/enums/compression_type.cpp @@ -24,6 +24,8 @@ bool CompressionTypeIsDeprecated(CompressionType compression_type) { 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") { @@ -83,6 +85,8 @@ string CompressionTypeToString(CompressionType type) { return "ALPRD"; case CompressionType::COMPRESSION_ROARING: return "Roaring"; + case CompressionType::COMPRESSION_EMPTY: + return "Empty Validity"; default: throw InternalException("Unrecognized compression type!"); } diff --git a/src/duckdb/src/common/file_system.cpp b/src/duckdb/src/common/file_system.cpp index 26ac7fee3..fbcf0cede 100644 --- a/src/duckdb/src/common/file_system.cpp +++ b/src/duckdb/src/common/file_system.cpp @@ -115,7 +115,7 @@ string FileSystem::GetEnvVariable(const string &name) { bool FileSystem::IsPathAbsolute(const string &path) { auto path_separator = PathSeparator(path); - return PathMatched(path, path_separator); + return PathMatched(path, path_separator) || StringUtil::StartsWith(path, "file:/"); } string FileSystem::PathSeparator(const string &path) { @@ -237,7 +237,11 @@ string FileSystem::NormalizeAbsolutePath(const string &path) { } string FileSystem::PathSeparator(const string &path) { - return "\\"; + if (StringUtil::StartsWith(path, "file:")) { + return "/"; + } else { + return "\\"; + } } void FileSystem::SetWorkingDirectory(const string &path) { diff --git a/src/duckdb/src/common/local_file_system.cpp b/src/duckdb/src/common/local_file_system.cpp index 2827b33e3..83e242526 100644 --- a/src/duckdb/src/common/local_file_system.cpp +++ b/src/duckdb/src/common/local_file_system.cpp @@ -59,13 +59,13 @@ extern "C" WINBASEAPI BOOL QueryFullProcessImageNameW(HANDLE, DWORD, LPWSTR, PDW #endif namespace duckdb { - #ifndef _WIN32 bool LocalFileSystem::FileExists(const string &filename, optional_ptr opener) { if (!filename.empty()) { - if (access(filename.c_str(), 0) == 0) { + auto normalized_file = NormalizeLocalPath(filename); + if (access(normalized_file, 0) == 0) { struct stat status; - stat(filename.c_str(), &status); + stat(normalized_file, &status); if (S_ISREG(status.st_mode)) { return true; } @@ -77,9 +77,10 @@ bool LocalFileSystem::FileExists(const string &filename, optional_ptr opener) { if (!filename.empty()) { - if (access(filename.c_str(), 0) == 0) { + auto normalized_file = NormalizeLocalPath(filename); + if (access(normalized_file, 0) == 0) { struct stat status; - stat(filename.c_str(), &status); + stat(normalized_file, &status); if (S_ISFIFO(status.st_mode)) { return true; } @@ -90,8 +91,21 @@ bool LocalFileSystem::IsPipe(const string &filename, optional_ptr op } #else +static std::wstring NormalizePathAndConvertToUnicode(const string &path) { + string normalized_path_copy; + const char *normalized_path; + if (StringUtil::StartsWith(path, "file:/")) { + normalized_path_copy = LocalFileSystem::NormalizeLocalPath(path); + normalized_path_copy = LocalFileSystem().ConvertSeparators(normalized_path_copy); + normalized_path = normalized_path_copy.c_str(); + } else { + normalized_path = path.c_str(); + } + return WindowsUtil::UTF8ToUnicode(normalized_path); +} + bool LocalFileSystem::FileExists(const string &filename, optional_ptr opener) { - auto unicode_path = WindowsUtil::UTF8ToUnicode(filename.c_str()); + auto unicode_path = NormalizePathAndConvertToUnicode(filename); const wchar_t *wpath = unicode_path.c_str(); if (_waccess(wpath, 0) == 0) { struct _stati64 status; @@ -103,7 +117,7 @@ bool LocalFileSystem::FileExists(const string &filename, optional_ptr opener) { - auto unicode_path = WindowsUtil::UTF8ToUnicode(filename.c_str()); + auto unicode_path = NormalizePathAndConvertToUnicode(filename); const wchar_t *wpath = unicode_path.c_str(); if (_waccess(wpath, 0) == 0) { struct _stati64 status; @@ -180,7 +194,7 @@ static string AdditionalProcessInfo(FileSystem &fs, pid_t pid) { } string process_name, process_owner; -// macOS >= 10.7 has PROC_PIDT_SHORTBSDINFO + // macOS >= 10.7 has PROC_PIDT_SHORTBSDINFO #ifdef PROC_PIDT_SHORTBSDINFO // try to find out more about the process holding the lock struct proc_bsdshortinfo proc; @@ -261,10 +275,11 @@ static string AdditionalProcessInfo(FileSystem &fs, pid_t pid) { bool LocalFileSystem::IsPrivateFile(const string &path_p, FileOpener *opener) { auto path = FileSystem::ExpandPath(path_p, opener); + auto normalized_path = NormalizeLocalPath(path); struct stat st; - if (lstat(path.c_str(), &st) != 0) { + if (lstat(normalized_path, &st) != 0) { throw IOException( "Failed to stat '%s' when checking file permissions, file may be missing or have incorrect permissions", path.c_str()); @@ -281,6 +296,7 @@ bool LocalFileSystem::IsPrivateFile(const string &path_p, FileOpener *opener) { unique_ptr LocalFileSystem::OpenFile(const string &path_p, FileOpenFlags flags, optional_ptr opener) { auto path = FileSystem::ExpandPath(path_p, opener); + auto normalized_path = NormalizeLocalPath(path); if (flags.Compression() != FileCompressionType::UNCOMPRESSED) { throw NotImplementedException("Unsupported compression type for default file system"); } @@ -338,7 +354,7 @@ unique_ptr LocalFileSystem::OpenFile(const string &path_p, FileOpenF } // Open the file - int fd = open(path.c_str(), open_flags, filesec); + int fd = open(normalized_path, open_flags, filesec); if (fd == -1) { if (flags.ReturnNullIfNotExists() && errno == ENOENT) { @@ -560,9 +576,10 @@ void LocalFileSystem::Truncate(FileHandle &handle, int64_t new_size) { bool LocalFileSystem::DirectoryExists(const string &directory, optional_ptr opener) { if (!directory.empty()) { - if (access(directory.c_str(), 0) == 0) { + auto normalized_dir = NormalizeLocalPath(directory); + if (access(normalized_dir, 0) == 0) { struct stat status; - stat(directory.c_str(), &status); + stat(normalized_dir, &status); if (status.st_mode & S_IFDIR) { return true; } @@ -575,9 +592,10 @@ bool LocalFileSystem::DirectoryExists(const string &directory, optional_ptr opener) { struct stat st; - if (stat(directory.c_str(), &st) != 0) { + auto normalized_dir = NormalizeLocalPath(directory); + if (stat(normalized_dir, &st) != 0) { /* Directory does not exist. EEXIST for race condition */ - if (mkdir(directory.c_str(), 0755) != 0 && errno != EEXIST) { + if (mkdir(normalized_dir, 0755) != 0 && errno != EEXIST) { throw IOException("Failed to create directory \"%s\": %s", {{"errno", std::to_string(errno)}}, directory, strerror(errno)); } @@ -628,11 +646,13 @@ int RemoveDirectoryRecursive(const char *path) { } void LocalFileSystem::RemoveDirectory(const string &directory, optional_ptr opener) { - RemoveDirectoryRecursive(directory.c_str()); + auto normalized_dir = NormalizeLocalPath(directory); + RemoveDirectoryRecursive(normalized_dir); } void LocalFileSystem::RemoveFile(const string &filename, optional_ptr opener) { - if (std::remove(filename.c_str()) != 0) { + auto normalized_file = NormalizeLocalPath(filename); + if (std::remove(normalized_file) != 0) { throw IOException("Could not remove file \"%s\": %s", {{"errno", std::to_string(errno)}}, filename, strerror(errno)); } @@ -640,7 +660,8 @@ void LocalFileSystem::RemoveFile(const string &filename, optional_ptr &callback, FileOpener *opener) { - auto dir = opendir(directory.c_str()); + auto normalized_dir = NormalizeLocalPath(directory); + auto dir = opendir(normalized_dir); if (!dir) { return false; } @@ -657,7 +678,7 @@ bool LocalFileSystem::ListFiles(const string &directory, const std::function opener) { + auto normalized_source = NormalizeLocalPath(source); + auto normalized_target = NormalizeLocalPath(target); //! FIXME: rename does not guarantee atomicity or overwriting target file if it exists - if (rename(source.c_str(), target.c_str()) != 0) { + if (rename(normalized_source, normalized_target) != 0) { throw IOException("Could not rename file!", {{"errno", std::to_string(errno)}}); } } @@ -808,6 +831,7 @@ bool LocalFileSystem::IsPrivateFile(const string &path_p, FileOpener *opener) { unique_ptr LocalFileSystem::OpenFile(const string &path_p, FileOpenFlags flags, optional_ptr opener) { auto path = FileSystem::ExpandPath(path_p, opener); + auto unicode_path = NormalizePathAndConvertToUnicode(path); if (flags.Compression() != FileCompressionType::UNCOMPRESSED) { throw NotImplementedException("Unsupported compression type for default file system"); } @@ -841,7 +865,6 @@ unique_ptr LocalFileSystem::OpenFile(const string &path_p, FileOpenF if (flags.DirectIO()) { flags_and_attributes |= FILE_FLAG_NO_BUFFERING; } - auto unicode_path = WindowsUtil::UTF8ToUnicode(path.c_str()); HANDLE hFile = CreateFileW(unicode_path.c_str(), desired_access, share_mode, NULL, creation_disposition, flags_and_attributes, NULL); if (hFile == INVALID_HANDLE_VALUE) { @@ -1016,10 +1039,14 @@ void LocalFileSystem::Truncate(FileHandle &handle, int64_t new_size) { } static DWORD WindowsGetFileAttributes(const string &filename) { - auto unicode_path = WindowsUtil::UTF8ToUnicode(filename.c_str()); + auto unicode_path = NormalizePathAndConvertToUnicode(filename); return GetFileAttributesW(unicode_path.c_str()); } +static DWORD WindowsGetFileAttributes(const std::wstring &filename) { + return GetFileAttributesW(filename.c_str()); +} + bool LocalFileSystem::DirectoryExists(const string &directory, optional_ptr opener) { DWORD attrs = WindowsGetFileAttributes(directory); return (attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY)); @@ -1029,7 +1056,7 @@ void LocalFileSystem::CreateDirectory(const string &directory, optional_ptr opener) { - auto unicode_path = WindowsUtil::UTF8ToUnicode(filename.c_str()); + auto unicode_path = NormalizePathAndConvertToUnicode(filename); if (!DeleteFileW(unicode_path.c_str())) { auto error = LocalFileSystem::GetLastErrorAsString(); throw IOException("Failed to delete file \"%s\": %s", filename, error); @@ -1072,8 +1099,7 @@ void LocalFileSystem::RemoveFile(const string &filename, optional_ptr &callback, FileOpener *opener) { string search_dir = JoinPath(directory, "*"); - - auto unicode_path = WindowsUtil::UTF8ToUnicode(search_dir.c_str()); + auto unicode_path = NormalizePathAndConvertToUnicode(search_dir); WIN32_FIND_DATAW ffd; HANDLE hFind = FindFirstFileW(unicode_path.c_str(), &ffd); @@ -1106,8 +1132,9 @@ void LocalFileSystem::FileSync(FileHandle &handle) { } void LocalFileSystem::MoveFile(const string &source, const string &target, optional_ptr opener) { - auto source_unicode = WindowsUtil::UTF8ToUnicode(source.c_str()); - auto target_unicode = WindowsUtil::UTF8ToUnicode(target.c_str()); + auto source_unicode = NormalizePathAndConvertToUnicode(source); + auto target_unicode = NormalizePathAndConvertToUnicode(target); + if (!MoveFileW(source_unicode.c_str(), target_unicode.c_str())) { throw IOException("Could not move file: %s", GetLastErrorAsString()); } @@ -1119,7 +1146,8 @@ FileType LocalFileSystem::GetFileType(FileHandle &handle) { if (strncmp(path.c_str(), PIPE_PREFIX, strlen(PIPE_PREFIX)) == 0) { return FileType::FILE_TYPE_FIFO; } - DWORD attrs = WindowsGetFileAttributes(path.c_str()); + auto normalized_path = NormalizePathAndConvertToUnicode(path); + DWORD attrs = WindowsGetFileAttributes(normalized_path); if (attrs != INVALID_FILE_ATTRIBUTES) { if (attrs & FILE_ATTRIBUTE_DIRECTORY) { return FileType::FILE_TYPE_DIR; @@ -1161,9 +1189,10 @@ 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 struct stat status; - return (lstat(path.c_str(), &status) != -1 && S_ISLNK(status.st_mode)); + return (lstat(normalized_path, &status) != -1 && S_ISLNK(status.st_mode)); #else auto attributes = WindowsGetFileAttributes(path); if (attributes == INVALID_FILE_ATTRIBUTES) @@ -1230,14 +1259,59 @@ vector LocalFileSystem::FetchFileWithoutGlob(const string &path, FileOpe return result; } +// Helper function to handle file:/ URLs +static idx_t GetFileUrlOffset(const string &path) { + if (!StringUtil::StartsWith(path, "file:/")) { + return 0; + } + + // Url without host: file:/some/path + if (path[6] != '/') { +#ifdef _WIN32 + return 6; +#else + return 5; +#endif + } + + // Url with empty host: file:///some/path + if (path[7] == '/') { +#ifdef _WIN32 + return 8; +#else + return 7; +#endif + } + + // Url with localhost: file://localhost/some/path + if (path.compare(7, 10, "localhost/") == 0) { +#ifdef _WIN32 + return 17; +#else + return 16; +#endif + } + + // unkown file:/ url format + return 0; +} + +const char *LocalFileSystem::NormalizeLocalPath(const string &path) { + return path.c_str() + GetFileUrlOffset(path); +} + vector LocalFileSystem::Glob(const string &path, FileOpener *opener) { if (path.empty()) { return vector(); } // 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; - for (idx_t i = 0; i < path.size(); i++) { + for (idx_t i = file_url_path_offset; i < path.size(); i++) { if (path[i] == '\\' || path[i] == '/') { if (i == last_pos) { // empty: skip this position @@ -1245,6 +1319,7 @@ vector LocalFileSystem::Glob(const string &path, FileOpener *opener) { 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)); } else { splits.push_back(path.substr(last_pos, i - last_pos)); @@ -1255,10 +1330,10 @@ vector LocalFileSystem::Glob(const string &path, FileOpener *opener) { splits.push_back(path.substr(last_pos, path.size() - last_pos)); // handle absolute paths bool absolute_path = false; - if (path[0] == '/') { + if (IsPathAbsolute(path)) { // first character is a slash - unix absolute path absolute_path = true; - } else if (StringUtil::Contains(splits[0], ":")) { + } else if (StringUtil::Contains(splits[0], ":")) { // TODO: this is weird? shouldn't IsPathAbsolute handle this? // first split has a colon - windows absolute path absolute_path = true; } else if (splits[0] == "~") { @@ -1298,7 +1373,16 @@ vector LocalFileSystem::Glob(const string &path, FileOpener *opener) { throw IOException("Cannot use multiple \'**\' in one path"); } - for (idx_t i = absolute_path ? 1 : 0; i < splits.size(); i++) { + idx_t start_index; + if (is_file_url) { + start_index = 1; + } else if (absolute_path) { + start_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 diff --git a/src/duckdb/src/common/operator/cast_operators.cpp b/src/duckdb/src/common/operator/cast_operators.cpp index fe1ce26af..9742c6087 100644 --- a/src/duckdb/src/common/operator/cast_operators.cpp +++ b/src/duckdb/src/common/operator/cast_operators.cpp @@ -1470,8 +1470,16 @@ bool TryCastToUUID::Operation(string_t input, hugeint_t &result, Vector &result_ //===--------------------------------------------------------------------===// template <> bool TryCastErrorMessage::Operation(string_t input, date_t &result, CastParameters ¶meters) { - if (!TryCast::Operation(input, result, parameters.strict)) { - HandleCastError::AssignError(Date::ConversionError(input), parameters); + idx_t pos; + bool special = false; + switch (Date::TryConvertDate(input.GetData(), input.GetSize(), pos, result, special, parameters.strict)) { + case DateCastResult::SUCCESS: + break; + case DateCastResult::ERROR_INCORRECT_FORMAT: + HandleCastError::AssignError(Date::FormatError(input), parameters); + return false; + case DateCastResult::ERROR_RANGE: + HandleCastError::AssignError(Date::RangeError(input), parameters); return false; } return true; @@ -1481,7 +1489,8 @@ template <> bool TryCast::Operation(string_t input, date_t &result, bool strict) { idx_t pos; bool special = false; - return Date::TryConvertDate(input.GetData(), input.GetSize(), pos, result, special, strict); + return Date::TryConvertDate(input.GetData(), input.GetSize(), pos, result, special, strict) == + DateCastResult::SUCCESS; } template <> @@ -1545,14 +1554,18 @@ dtime_tz_t Cast::Operation(string_t input) { //===--------------------------------------------------------------------===// template <> bool TryCastErrorMessage::Operation(string_t input, timestamp_t &result, CastParameters ¶meters) { - auto cast_result = Timestamp::TryConvertTimestamp(input.GetData(), input.GetSize(), result); - if (cast_result == TimestampCastResult::SUCCESS) { + switch (Timestamp::TryConvertTimestamp(input.GetData(), input.GetSize(), result)) { + case TimestampCastResult::SUCCESS: return true; - } - if (cast_result == TimestampCastResult::ERROR_INCORRECT_FORMAT) { - HandleCastError::AssignError(Timestamp::ConversionError(input), parameters); - } else { + case TimestampCastResult::ERROR_INCORRECT_FORMAT: + HandleCastError::AssignError(Timestamp::FormatError(input), parameters); + break; + case TimestampCastResult::ERROR_NON_UTC_TIMEZONE: HandleCastError::AssignError(Timestamp::UnsupportedTimezoneError(input), parameters); + break; + case TimestampCastResult::ERROR_RANGE: + HandleCastError::AssignError(Timestamp::RangeError(input), parameters); + break; } return false; } @@ -1578,7 +1591,7 @@ timestamp_ns_t Cast::Operation(string_t input) { const auto ts = Timestamp::FromCString(input.GetData(), input.GetSize(), &nanos); timestamp_ns_t result; if (!Timestamp::TryFromTimestampNanos(ts, nanos, result)) { - throw ConversionException(Timestamp::ConversionError(input)); + throw ConversionException(Timestamp::RangeError(input)); } return result; } diff --git a/src/duckdb/src/common/random_engine.cpp b/src/duckdb/src/common/random_engine.cpp index 7741e8f4d..23eb253e3 100644 --- a/src/duckdb/src/common/random_engine.cpp +++ b/src/duckdb/src/common/random_engine.cpp @@ -1,8 +1,13 @@ #include "duckdb/common/random_engine.hpp" #include "duckdb/common/numeric_utils.hpp" #include "pcg_random.hpp" -#include +#ifdef __linux__ +#include +#include +#else +#include +#endif namespace duckdb { struct RandomState { @@ -14,7 +19,18 @@ struct RandomState { RandomEngine::RandomEngine(int64_t seed) : random_state(make_uniq()) { if (seed < 0) { +#ifdef __linux__ + idx_t random_seed; + auto result = syscall(SYS_getrandom, &random_seed, sizeof(random_seed), 0); + if (result == -1) { + // Something went wrong with the syscall, we use chrono + const auto now = std::chrono::high_resolution_clock::now(); + random_seed = now.time_since_epoch().count(); + } + random_state->pcg.seed(random_seed); +#else random_state->pcg.seed(pcg_extras::seed_seq_from()); +#endif } else { random_state->pcg.seed(NumericCast(seed)); } diff --git a/src/duckdb/src/common/string_util.cpp b/src/duckdb/src/common/string_util.cpp index f1bd1e038..f96e3d64e 100644 --- a/src/duckdb/src/common/string_util.cpp +++ b/src/duckdb/src/common/string_util.cpp @@ -6,6 +6,7 @@ #include "duckdb/common/to_string.hpp" #include "duckdb/common/helper.hpp" #include "duckdb/common/exception/parser_exception.hpp" +#include "duckdb/common/random_engine.hpp" #include "jaro_winkler.hpp" #include "utf8proc_wrapper.hpp" @@ -16,7 +17,6 @@ #include #include #include -#include #include #include "yyjson.hpp" @@ -26,13 +26,10 @@ using namespace duckdb_yyjson; // NOLINT namespace duckdb { string StringUtil::GenerateRandomName(idx_t length) { - std::random_device rd; - std::mt19937 gen(rd()); - std::uniform_int_distribution<> dis(0, 15); - + RandomEngine engine; std::stringstream ss; for (idx_t i = 0; i < length; i++) { - ss << "0123456789abcdef"[dis(gen)]; + ss << "0123456789abcdef"[engine.NextRandomInteger(0, 15)]; } return ss.str(); } diff --git a/src/duckdb/src/common/types/date.cpp b/src/duckdb/src/common/types/date.cpp index 7c9f78ca8..429ee0311 100644 --- a/src/duckdb/src/common/types/date.cpp +++ b/src/duckdb/src/common/types/date.cpp @@ -205,11 +205,12 @@ bool Date::TryConvertDateSpecial(const char *buf, idx_t len, idx_t &pos, const c return true; } -bool Date::TryConvertDate(const char *buf, idx_t len, idx_t &pos, date_t &result, bool &special, bool strict) { +DateCastResult Date::TryConvertDate(const char *buf, idx_t len, idx_t &pos, date_t &result, bool &special, + bool strict) { special = false; pos = 0; if (len == 0) { - return false; + return DateCastResult::ERROR_INCORRECT_FORMAT; } int32_t day = 0; @@ -224,13 +225,13 @@ bool Date::TryConvertDate(const char *buf, idx_t len, idx_t &pos, date_t &result } if (pos >= len) { - return false; + return DateCastResult::ERROR_INCORRECT_FORMAT; } if (buf[pos] == '-') { yearneg = true; pos++; if (pos >= len) { - return false; + return DateCastResult::ERROR_INCORRECT_FORMAT; } } if (!StringUtil::CharacterIsDigit(buf[pos])) { @@ -240,62 +241,62 @@ bool Date::TryConvertDate(const char *buf, idx_t len, idx_t &pos, date_t &result } else if (TryConvertDateSpecial(buf, len, pos, EPOCH)) { result = date_t::epoch(); } else { - return false; + return DateCastResult::ERROR_INCORRECT_FORMAT; } // skip trailing spaces - parsing must be strict here while (pos < len && StringUtil::CharacterIsSpace(buf[pos])) { pos++; } special = true; - return pos == len; + return (pos == len) ? DateCastResult::SUCCESS : DateCastResult::ERROR_INCORRECT_FORMAT; } // first parse the year idx_t year_length = 0; for (; pos < len && StringUtil::CharacterIsDigit(buf[pos]); pos++) { if (year >= 100000000) { - return false; + return DateCastResult::ERROR_RANGE; } year = (buf[pos] - '0') + year * 10; year_length++; } if (year_length < 2 && strict) { - return false; + return DateCastResult::ERROR_INCORRECT_FORMAT; } if (yearneg) { year = -year; } if (pos >= len) { - return false; + return DateCastResult::ERROR_INCORRECT_FORMAT; } // fetch the separator sep = buf[pos++]; if (sep != ' ' && sep != '-' && sep != '/' && sep != '\\') { // invalid separator - return false; + return DateCastResult::ERROR_INCORRECT_FORMAT; } // parse the month if (!Date::ParseDoubleDigit(buf, len, pos, month)) { - return false; + return DateCastResult::ERROR_INCORRECT_FORMAT; } if (pos >= len) { - return false; + return DateCastResult::ERROR_INCORRECT_FORMAT; } if (buf[pos++] != sep) { - return false; + return DateCastResult::ERROR_INCORRECT_FORMAT; } if (pos >= len) { - return false; + return DateCastResult::ERROR_INCORRECT_FORMAT; } // now parse the day if (!Date::ParseDoubleDigit(buf, len, pos, day)) { - return false; + return DateCastResult::ERROR_INCORRECT_FORMAT; } // check for an optional trailing " (BC)"" @@ -303,7 +304,7 @@ bool Date::TryConvertDate(const char *buf, idx_t len, idx_t &pos, date_t &result StringUtil::CharacterToLower(buf[pos + 2]) == 'b' && StringUtil::CharacterToLower(buf[pos + 3]) == 'c' && buf[pos + 4] == ')') { if (yearneg || year == 0) { - return false; + return DateCastResult::ERROR_INCORRECT_FORMAT; } year = -year + 1; pos += 5; @@ -317,34 +318,47 @@ bool Date::TryConvertDate(const char *buf, idx_t len, idx_t &pos, date_t &result } // check position. if end was not reached, non-space chars remaining if (pos < len) { - return false; + return DateCastResult::ERROR_INCORRECT_FORMAT; } } else { // in non-strict mode, check for any direct trailing digits if (pos < len && StringUtil::CharacterIsDigit(buf[pos])) { - return false; + return DateCastResult::ERROR_INCORRECT_FORMAT; } } - return Date::TryFromDate(year, month, day, result); + return Date::TryFromDate(year, month, day, result) ? DateCastResult::SUCCESS : DateCastResult::ERROR_RANGE; } -string Date::ConversionError(const string &str) { - return StringUtil::Format("date field value out of range: \"%s\", " +string Date::FormatError(const string &str) { + return StringUtil::Format("invalid date field format: \"%s\", " "expected format is (YYYY-MM-DD)", str); } -string Date::ConversionError(string_t str) { - return ConversionError(str.GetString()); +string Date::RangeError(const string &str) { + return StringUtil::Format("date field value out of range: \"%s\"", str); +} + +string Date::RangeError(string_t str) { + return RangeError(str.GetString()); +} + +string Date::FormatError(string_t str) { + return FormatError(str.GetString()); } date_t Date::FromCString(const char *buf, idx_t len, bool strict) { date_t result; idx_t pos; bool special = false; - if (!TryConvertDate(buf, len, pos, result, special, strict)) { - throw ConversionException(ConversionError(string(buf, len))); + switch (TryConvertDate(buf, len, pos, result, special, strict)) { + case DateCastResult::ERROR_INCORRECT_FORMAT: + throw ConversionException(FormatError(string(buf, len))); + case DateCastResult::ERROR_RANGE: + throw ConversionException(RangeError(string(buf, len))); + case DateCastResult::SUCCESS: + break; } return result; } diff --git a/src/duckdb/src/common/types/timestamp.cpp b/src/duckdb/src/common/types/timestamp.cpp index dbc40a6e8..d596e7530 100644 --- a/src/duckdb/src/common/types/timestamp.cpp +++ b/src/duckdb/src/common/types/timestamp.cpp @@ -64,25 +64,31 @@ timestamp_t ×tamp_t::operator-=(const int64_t &delta) { return *this; } -bool Timestamp::TryConvertTimestampTZ(const char *str, idx_t len, timestamp_t &result, bool &has_offset, string_t &tz, - optional_ptr nanos) { +TimestampCastResult Timestamp::TryConvertTimestampTZ(const char *str, idx_t len, timestamp_t &result, bool &has_offset, + string_t &tz, optional_ptr nanos) { idx_t pos; date_t date; dtime_t time; has_offset = false; - if (!Date::TryConvertDate(str, len, pos, date, has_offset)) { - return false; + switch (Date::TryConvertDate(str, len, pos, date, has_offset)) { + case DateCastResult::ERROR_INCORRECT_FORMAT: + return TimestampCastResult::ERROR_INCORRECT_FORMAT; + case DateCastResult::ERROR_RANGE: + return TimestampCastResult::ERROR_RANGE; + default: + break; } if (pos == len) { // no time: only a date or special if (date == date_t::infinity()) { result = timestamp_t::infinity(); - return true; + return TimestampCastResult::SUCCESS; } else if (date == date_t::ninfinity()) { result = timestamp_t::ninfinity(); - return true; + return TimestampCastResult::SUCCESS; } - return Timestamp::TryFromDatetime(date, dtime_t(0), result); + return Timestamp::TryFromDatetime(date, dtime_t(0), result) ? TimestampCastResult::SUCCESS + : TimestampCastResult::ERROR_RANGE; } // try to parse a time field if (str[pos] == ' ' || str[pos] == 'T') { @@ -93,15 +99,15 @@ bool Timestamp::TryConvertTimestampTZ(const char *str, idx_t len, timestamp_t &r // operation. Note that we can't pass strict== true here because we // want to process any suffix. if (!Time::TryConvertInterval(str + pos, len - pos, time_pos, time, false, nanos)) { - return false; + return TimestampCastResult::ERROR_INCORRECT_FORMAT; } // We parsed an interval, so make sure it is in range. if (time.micros > Interval::MICROS_PER_DAY) { - return false; + return TimestampCastResult::ERROR_RANGE; } pos += time_pos; if (!Timestamp::TryFromDatetime(date, time, result)) { - return false; + return TimestampCastResult::ERROR_RANGE; } if (pos < len) { // skip a "Z" at the end (as per the ISO8601 specs) @@ -112,13 +118,13 @@ bool Timestamp::TryConvertTimestampTZ(const char *str, idx_t len, timestamp_t &r } else if (Timestamp::TryParseUTCOffset(str, pos, len, hour_offset, minute_offset)) { const int64_t delta = hour_offset * Interval::MICROS_PER_HOUR + minute_offset * Interval::MICROS_PER_MINUTE; if (!TrySubtractOperator::Operation(result.value, delta, result.value)) { - return false; + return TimestampCastResult::ERROR_RANGE; } has_offset = true; } else { // Parse a time zone: / [A-Za-z0-9/_]+/ if (str[pos++] != ' ') { - return false; + return TimestampCastResult::ERROR_NON_UTC_TIMEZONE; } auto tz_name = str + pos; for (; pos < len && CharacterIsTimeZone(str[pos]); ++pos) { @@ -136,10 +142,10 @@ bool Timestamp::TryConvertTimestampTZ(const char *str, idx_t len, timestamp_t &r pos++; } if (pos < len) { - return false; + return TimestampCastResult::ERROR_INCORRECT_FORMAT; } } - return true; + return TimestampCastResult::SUCCESS; } TimestampCastResult Timestamp::TryConvertTimestamp(const char *str, idx_t len, timestamp_t &result, @@ -148,8 +154,8 @@ TimestampCastResult Timestamp::TryConvertTimestamp(const char *str, idx_t len, t bool has_offset = false; // We don't understand TZ without an extension, so fail if one was provided. auto success = TryConvertTimestampTZ(str, len, result, has_offset, tz, nanos); - if (!success) { - return TimestampCastResult::ERROR_INCORRECT_FORMAT; + if (success != TimestampCastResult::SUCCESS) { + return success; } if (tz.GetSize() == 0) { // no timezone provided - success! @@ -176,7 +182,11 @@ bool Timestamp::TryFromTimestampNanos(timestamp_t input, int32_t nanos, timestam return false; } - return TryAddOperator::Operation(result.value, int64_t(nanos), result.value); + if (!TryAddOperator::Operation(result.value, int64_t(nanos), result.value)) { + return false; + } + + return IsFinite(result); } TimestampCastResult Timestamp::TryConvertTimestamp(const char *str, idx_t len, timestamp_ns_t &result) { @@ -191,8 +201,8 @@ TimestampCastResult Timestamp::TryConvertTimestamp(const char *str, idx_t len, t return TimestampCastResult::SUCCESS; } -string Timestamp::ConversionError(const string &str) { - return StringUtil::Format("timestamp field value out of range: \"%s\", " +string Timestamp::FormatError(const string &str) { + return StringUtil::Format("invalid timestamp field format: \"%s\", " "expected format is (YYYY-MM-DD HH:MM:SS[.US][±HH:MM| ZONE])", str); } @@ -203,25 +213,35 @@ string Timestamp::UnsupportedTimezoneError(const string &str) { str); } -string Timestamp::ConversionError(string_t str) { - return Timestamp::ConversionError(str.GetString()); +string Timestamp::RangeError(const string &str) { + return StringUtil::Format("timestamp field value out of range: \"%s\"", str); +} + +string Timestamp::FormatError(string_t str) { + return Timestamp::FormatError(str.GetString()); } string Timestamp::UnsupportedTimezoneError(string_t str) { return Timestamp::UnsupportedTimezoneError(str.GetString()); } +string Timestamp::RangeError(string_t str) { + return Timestamp::RangeError(str.GetString()); +} + timestamp_t Timestamp::FromCString(const char *str, idx_t len, optional_ptr nanos) { timestamp_t result; - auto cast_result = Timestamp::TryConvertTimestamp(str, len, result, nanos); - if (cast_result == TimestampCastResult::SUCCESS) { - return result; - } - if (cast_result == TimestampCastResult::ERROR_NON_UTC_TIMEZONE) { - throw ConversionException(Timestamp::UnsupportedTimezoneError(string(str, len))); - } else { - throw ConversionException(Timestamp::ConversionError(string(str, len))); + switch (Timestamp::TryConvertTimestamp(str, len, result, nanos)) { + case TimestampCastResult::SUCCESS: + break; + case TimestampCastResult::ERROR_NON_UTC_TIMEZONE: + throw ConversionException(UnsupportedTimezoneError(string(str, len))); + case TimestampCastResult::ERROR_INCORRECT_FORMAT: + throw ConversionException(FormatError(string(str, len))); + case TimestampCastResult::ERROR_RANGE: + throw ConversionException(RangeError(string(str, len))); } + return result; } bool Timestamp::TryParseUTCOffset(const char *str, idx_t &pos, idx_t len, int &hour_offset, int &minute_offset) { @@ -334,7 +354,7 @@ bool Timestamp::TryFromDatetime(date_t date, dtime_tz_t timetz, timestamp_t &res timestamp_t Timestamp::FromDatetime(date_t date, dtime_t time) { timestamp_t result; if (!TryFromDatetime(date, time, result)) { - throw ConversionException("Overflow exception in date/time -> timestamp conversion"); + throw ConversionException("Date and time not in timestamp range"); } return result; } diff --git a/src/duckdb/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp b/src/duckdb/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp index aeb305a55..c1ab79dfe 100644 --- a/src/duckdb/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp +++ b/src/duckdb/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp @@ -334,8 +334,9 @@ void StringValueResult::AddValueToVector(const char *value_ptr, const idx_t size } else { idx_t pos; bool special; - success = Date::TryConvertDate( - value_ptr, size, pos, static_cast(vector_ptr[chunk_col_id])[number_of_rows], special, false); + success = Date::TryConvertDate(value_ptr, size, pos, + static_cast(vector_ptr[chunk_col_id])[number_of_rows], special, + false) == DateCastResult::SUCCESS; } break; } diff --git a/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_detection.cpp b/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_detection.cpp index 49bf105a9..d6b2b1a6b 100644 --- a/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_detection.cpp +++ b/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_detection.cpp @@ -162,7 +162,7 @@ bool CSVSniffer::CanYouCastIt(ClientContext &context, const string_t value, cons idx_t pos; bool special; date_t dummy_value; - return Date::TryConvertDate(value_ptr, value_size, pos, dummy_value, special, true); + return Date::TryConvertDate(value_ptr, value_size, pos, dummy_value, special, true) == DateCastResult::SUCCESS; } case LogicalTypeId::TIMESTAMP: { timestamp_t dummy_value; 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 d8cb58e32..4e7455efa 100644 --- a/src/duckdb/src/function/aggregate/distributive/first_last_any.cpp +++ b/src/duckdb/src/function/aggregate/distributive/first_last_any.cpp @@ -216,9 +216,23 @@ struct FirstVectorFunction : FirstFunctionStringBase { } }; +template +static 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) { + // 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 static AggregateFunction GetFirstAggregateTemplated(LogicalType type) { - return AggregateFunction::UnaryAggregate, T, T, FirstFunction>(type, type); + auto result = AggregateFunction::UnaryAggregate, T, T, FirstFunction>(type, type); + result.simple_update = FirstFunctionSimpleUpdate; + return result; } template diff --git a/src/duckdb/src/function/cast/struct_cast.cpp b/src/duckdb/src/function/cast/struct_cast.cpp index e5902b752..051581c54 100644 --- a/src/duckdb/src/function/cast/struct_cast.cpp +++ b/src/duckdb/src/function/cast/struct_cast.cpp @@ -128,6 +128,7 @@ static bool StructToStructCast(Vector &source, Vector &result, idx_t count, Cast source.Flatten(count); auto &result_validity = FlatVector::Validity(result); result_validity = FlatVector::Validity(source); + result.Verify(count); return all_converted; } diff --git a/src/duckdb/src/function/compression_config.cpp b/src/duckdb/src/function/compression_config.cpp index c0a7f1609..deece1a85 100644 --- a/src/duckdb/src/function/compression_config.cpp +++ b/src/duckdb/src/function/compression_config.cpp @@ -28,6 +28,8 @@ static const DefaultCompressionMethod internal_compression_methods[] = { {CompressionType::COMPRESSION_FSST, FSSTFun::GetFunction, FSSTFun::TypeIsSupported}, {CompressionType::COMPRESSION_ZSTD, ZSTDFun::GetFunction, ZSTDFun::TypeIsSupported}, {CompressionType::COMPRESSION_ROARING, RoaringCompressionFun::GetFunction, RoaringCompressionFun::TypeIsSupported}, + {CompressionType::COMPRESSION_EMPTY, EmptyValidityCompressionFun::GetFunction, + EmptyValidityCompressionFun::TypeIsSupported}, {CompressionType::COMPRESSION_AUTO, nullptr, nullptr}}; static optional_ptr FindCompressionFunction(CompressionFunctionSet &set, CompressionType type, diff --git a/src/duckdb/src/function/table/arrow_conversion.cpp b/src/duckdb/src/function/table/arrow_conversion.cpp index 18daff2b9..e09f81aac 100644 --- a/src/duckdb/src/function/table/arrow_conversion.cpp +++ b/src/duckdb/src/function/table/arrow_conversion.cpp @@ -725,6 +725,9 @@ static void ColumnArrowToDuckDBRunEndEncoded(Vector &vector, const ArrowArray &a D_ASSERT(vector.GetType() == values_type.GetDuckType()); auto &scan_state = array_state.state; + if (vector.GetBuffer()) { + vector.GetBuffer()->SetAuxiliaryData(make_uniq(array_state.owned_data)); + } D_ASSERT(run_ends_array.length == values_array.length); auto compressed_size = NumericCast(run_ends_array.length); @@ -766,6 +769,9 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca auto &scan_state = array_state.state; D_ASSERT(!array.dictionary); + if (vector.GetBuffer()) { + vector.GetBuffer()->SetAuxiliaryData(make_uniq(array_state.owned_data)); + } switch (vector.GetType().id()) { case LogicalTypeId::SQLNULL: vector.Reference(Value()); @@ -1284,6 +1290,9 @@ static bool CanContainNull(const ArrowArray &array, const ValidityMask *parent_m static void ColumnArrowToDuckDBDictionary(Vector &vector, ArrowArray &array, ArrowArrayScanState &array_state, idx_t size, const ArrowType &arrow_type, int64_t nested_offset, const ValidityMask *parent_mask, uint64_t parent_offset) { + if (vector.GetBuffer()) { + vector.GetBuffer()->SetAuxiliaryData(make_uniq(array_state.owned_data)); + } D_ASSERT(arrow_type.HasDictionary()); auto &scan_state = array_state.state; const bool has_nulls = CanContainNull(array, parent_mask); @@ -1384,7 +1393,6 @@ void ArrowTableFunction::ArrowToDuckDB(ArrowScanLocalState &scan_state, const ar if (!array_state.owned_data) { array_state.owned_data = scan_state.chunk; } - output.data[idx].GetBuffer()->SetAuxiliaryData(make_uniq(array_state.owned_data)); auto array_physical_type = GetArrowArrayPhysicalType(arrow_type); diff --git a/src/duckdb/src/function/table/version/pragma_version.cpp b/src/duckdb/src/function/table/version/pragma_version.cpp index 28c14cfbc..a98a327c6 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 "4-dev4166" +#define DUCKDB_PATCH_VERSION "4-dev4271" #endif #ifndef DUCKDB_MINOR_VERSION #define DUCKDB_MINOR_VERSION 1 @@ -8,10 +8,10 @@ #define DUCKDB_MAJOR_VERSION 1 #endif #ifndef DUCKDB_VERSION -#define DUCKDB_VERSION "v1.1.4-dev4166" +#define DUCKDB_VERSION "v1.1.4-dev4271" #endif #ifndef DUCKDB_SOURCE_ID -#define DUCKDB_SOURCE_ID "c28ce39350" +#define DUCKDB_SOURCE_ID "d707b4432b" #endif #include "duckdb/function/table/system_functions.hpp" #include "duckdb/main/database.hpp" diff --git a/src/duckdb/src/function/window/window_aggregate_function.cpp b/src/duckdb/src/function/window/window_aggregate_function.cpp index 32dc0a276..308667601 100644 --- a/src/duckdb/src/function/window/window_aggregate_function.cpp +++ b/src/duckdb/src/function/window/window_aggregate_function.cpp @@ -26,117 +26,50 @@ class WindowAggregateExecutorGlobalState : public WindowExecutorGlobalState { const Expression *filter_ref; }; -bool WindowAggregateExecutor::IsConstantAggregate() { - if (!wexpr.aggregate) { - return false; - } - // window exclusion cannot be handled by constant aggregates - if (wexpr.exclude_clause != WindowExcludeMode::NO_OTHER) { - return false; - } - - // COUNT(*) is already handled efficiently by segment trees. - if (wexpr.children.empty()) { - return false; - } - - /* - The default framing option is RANGE UNBOUNDED PRECEDING, which - is the same as RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT - ROW; it sets the frame to be all rows from the partition start - up through the current row's last peer (a row that the window's - ORDER BY clause considers equivalent to the current row; all - rows are peers if there is no ORDER BY). In general, UNBOUNDED - PRECEDING means that the frame starts with the first row of the - partition, and similarly UNBOUNDED FOLLOWING means that the - frame ends with the last row of the partition, regardless of - RANGE, ROWS or GROUPS mode. In ROWS mode, CURRENT ROW means that - the frame starts or ends with the current row; but in RANGE or - GROUPS mode it means that the frame starts or ends with the - current row's first or last peer in the ORDER BY ordering. The - offset PRECEDING and offset FOLLOWING options vary in meaning - depending on the frame mode. - */ - switch (wexpr.start) { - case WindowBoundary::UNBOUNDED_PRECEDING: - break; - case WindowBoundary::CURRENT_ROW_RANGE: - if (!wexpr.orders.empty()) { - return false; +static BoundWindowExpression &SimplifyWindowedAggregate(BoundWindowExpression &wexpr, ClientContext &context) { + // Remove redundant/irrelevant modifiers (they can be serious performance cliffs) + if (wexpr.aggregate && ClientConfig::GetConfig(context).enable_optimizer) { + const auto &aggr = wexpr.aggregate; + auto &arg_orders = wexpr.arg_orders; + if (aggr->distinct_dependent != AggregateDistinctDependent::DISTINCT_DEPENDENT) { + wexpr.distinct = false; } - break; - default: - return false; - } - - switch (wexpr.end) { - case WindowBoundary::UNBOUNDED_FOLLOWING: - break; - case WindowBoundary::CURRENT_ROW_RANGE: - if (!wexpr.orders.empty()) { - return false; + if (aggr->order_dependent != AggregateOrderDependent::ORDER_DEPENDENT) { + arg_orders.clear(); + } else { + // If the argument order is prefix of the partition ordering, + // then we can just use the partition ordering. + if (BoundWindowExpression::GetSharedOrders(wexpr.orders, arg_orders) == arg_orders.size()) { + arg_orders.clear(); + } } - break; - default: - return false; - } - - return true; -} - -bool WindowAggregateExecutor::IsDistinctAggregate() { - if (!wexpr.aggregate) { - return false; } - return wexpr.distinct; -} - -bool WindowAggregateExecutor::IsCustomAggregate() { - if (!wexpr.aggregate) { - return false; - } - - if (!AggregateObject(wexpr).function.window) { - return false; - } - - return (mode < WindowAggregationMode::COMBINE); -} - -void WindowExecutor::Evaluate(idx_t row_idx, DataChunk &eval_chunk, Vector &result, WindowExecutorLocalState &lstate, - WindowExecutorGlobalState &gstate) const { - auto &lbstate = lstate.Cast(); - lbstate.UpdateBounds(gstate, row_idx, eval_chunk, lstate.range_cursor); - - const auto count = eval_chunk.size(); - EvaluateInternal(gstate, lstate, eval_chunk, result, count, row_idx); - - result.Verify(count); + return wexpr; } WindowAggregateExecutor::WindowAggregateExecutor(BoundWindowExpression &wexpr, ClientContext &context, WindowSharedExpressions &shared, WindowAggregationMode mode) - : WindowExecutor(wexpr, context, shared), mode(mode) { - auto return_type = wexpr.return_type; + : WindowExecutor(SimplifyWindowedAggregate(wexpr, context), context, shared), mode(mode) { // Force naive for SEPARATE mode or for (currently!) unsupported functionality - const auto force_naive = - !ClientConfig::GetConfig(context).enable_optimizer || mode == WindowAggregationMode::SEPARATE; - if (force_naive || (wexpr.distinct && wexpr.exclude_clause != WindowExcludeMode::NO_OTHER)) { - aggregator = make_uniq(wexpr, wexpr.exclude_clause, shared); - } else if (IsDistinctAggregate()) { + if (!ClientConfig::GetConfig(context).enable_optimizer || mode == WindowAggregationMode::SEPARATE) { + aggregator = make_uniq(*this, shared); + } else if (WindowDistinctAggregator::CanAggregate(wexpr)) { // build a merge sort tree // see https://dl.acm.org/doi/pdf/10.1145/3514221.3526184 - aggregator = make_uniq(wexpr, wexpr.exclude_clause, shared, context); - } else if (IsConstantAggregate()) { - aggregator = make_uniq(wexpr, wexpr.exclude_clause, shared); - } else if (IsCustomAggregate()) { - aggregator = make_uniq(wexpr, wexpr.exclude_clause, shared); - } else { + aggregator = make_uniq(wexpr, shared, context); + } else if (WindowConstantAggregator::CanAggregate(wexpr)) { + aggregator = make_uniq(wexpr, shared); + } else if (WindowCustomAggregator::CanAggregate(wexpr, mode)) { + aggregator = make_uniq(wexpr, shared); + } else if (WindowSegmentTree::CanAggregate(wexpr)) { // build a segment tree for frame-adhering aggregates // see http://www.vldb.org/pvldb/vol8/p1058-leis.pdf - aggregator = make_uniq(wexpr, mode, wexpr.exclude_clause, shared); + aggregator = make_uniq(wexpr, shared); + } else { + // No accelerator can handle this combination, so fall back to naïve. + aggregator = make_uniq(*this, shared); } // Compute the FILTER with the other eval columns. diff --git a/src/duckdb/src/function/window/window_aggregator.cpp b/src/duckdb/src/function/window/window_aggregator.cpp index 60499073f..197b89e38 100644 --- a/src/duckdb/src/function/window/window_aggregator.cpp +++ b/src/duckdb/src/function/window/window_aggregator.cpp @@ -12,18 +12,17 @@ namespace duckdb { WindowAggregatorState::WindowAggregatorState() : allocator(Allocator::DefaultAllocator()) { } -WindowAggregator::WindowAggregator(const BoundWindowExpression &wexpr, const WindowExcludeMode exclude_mode_p) +WindowAggregator::WindowAggregator(const BoundWindowExpression &wexpr) : wexpr(wexpr), aggr(wexpr), result_type(wexpr.return_type), state_size(aggr.function.state_size(aggr.function)), - exclude_mode(exclude_mode_p) { + exclude_mode(wexpr.exclude_clause) { for (auto &child : wexpr.children) { arg_types.emplace_back(child->return_type); } } -WindowAggregator::WindowAggregator(const BoundWindowExpression &wexpr, const WindowExcludeMode exclude_mode_p, - WindowSharedExpressions &shared) - : WindowAggregator(wexpr, exclude_mode_p) { +WindowAggregator::WindowAggregator(const BoundWindowExpression &wexpr, WindowSharedExpressions &shared) + : WindowAggregator(wexpr) { for (auto &child : wexpr.children) { child_idx.emplace_back(shared.RegisterCollection(child, false)); } diff --git a/src/duckdb/src/function/window/window_constant_aggregator.cpp b/src/duckdb/src/function/window/window_constant_aggregator.cpp index d94267f91..4be038229 100644 --- a/src/duckdb/src/function/window/window_constant_aggregator.cpp +++ b/src/duckdb/src/function/window/window_constant_aggregator.cpp @@ -6,7 +6,7 @@ namespace duckdb { //===--------------------------------------------------------------------===// -// WindowConstantAggregator +// WindowConstantAggregatorGlobalState //===--------------------------------------------------------------------===// class WindowConstantAggregatorGlobalState : public WindowAggregatorGlobalState { @@ -24,33 +24,6 @@ class WindowConstantAggregatorGlobalState : public WindowAggregatorGlobalState { unique_ptr results; }; -class WindowConstantAggregatorLocalState : public WindowAggregatorLocalState { -public: - explicit WindowConstantAggregatorLocalState(const WindowConstantAggregatorGlobalState &gstate); - ~WindowConstantAggregatorLocalState() override { - } - - void Sink(DataChunk &sink_chunk, DataChunk &coll_chunk, idx_t input_idx, optional_ptr filter_sel, - idx_t filtered); - void Combine(WindowConstantAggregatorGlobalState &gstate); - -public: - //! The global state we are sharing - const WindowConstantAggregatorGlobalState &gstate; - //! Reusable chunk for sinking - DataChunk inputs; - //! Chunk for referencing the input columns - DataChunk payload_chunk; - //! A vector of pointers to "state", used for intermediate window segment aggregation - Vector statep; - //! Reused result state container for the window functions - WindowAggregateStates statef; - //! The current result partition being read - idx_t partition; - //! Shared SV for evaluation - SelectionVector matches; -}; - WindowConstantAggregatorGlobalState::WindowConstantAggregatorGlobalState(ClientContext &context, const WindowConstantAggregator &aggregator, idx_t group_count, @@ -93,6 +66,36 @@ WindowConstantAggregatorGlobalState::WindowConstantAggregatorGlobalState(ClientC partition_offsets.emplace_back(group_count); } +//===--------------------------------------------------------------------===// +// WindowConstantAggregatorLocalState +//===--------------------------------------------------------------------===// +class WindowConstantAggregatorLocalState : public WindowAggregatorLocalState { +public: + explicit WindowConstantAggregatorLocalState(const WindowConstantAggregatorGlobalState &gstate); + ~WindowConstantAggregatorLocalState() override { + } + + void Sink(DataChunk &sink_chunk, DataChunk &coll_chunk, idx_t input_idx, optional_ptr filter_sel, + idx_t filtered); + void Combine(WindowConstantAggregatorGlobalState &gstate); + +public: + //! The global state we are sharing + const WindowConstantAggregatorGlobalState &gstate; + //! Reusable chunk for sinking + DataChunk inputs; + //! Chunk for referencing the input columns + DataChunk payload_chunk; + //! A vector of pointers to "state", used for intermediate window segment aggregation + Vector statep; + //! Reused result state container for the window functions + WindowAggregateStates statef; + //! The current result partition being read + idx_t partition; + //! Shared SV for evaluation + SelectionVector matches; +}; + WindowConstantAggregatorLocalState::WindowConstantAggregatorLocalState( const WindowConstantAggregatorGlobalState &gstate) : gstate(gstate), statep(Value::POINTER(0)), statef(gstate.statef.aggr), partition(0) { @@ -110,10 +113,80 @@ WindowConstantAggregatorLocalState::WindowConstantAggregatorLocalState( gstate.locals++; } -WindowConstantAggregator::WindowConstantAggregator(const BoundWindowExpression &wexpr, - const WindowExcludeMode exclude_mode_p, - WindowSharedExpressions &shared) - : WindowAggregator(wexpr, exclude_mode_p) { +//===--------------------------------------------------------------------===// +// WindowConstantAggregator +//===--------------------------------------------------------------------===// +bool WindowConstantAggregator::CanAggregate(const BoundWindowExpression &wexpr) { + if (!wexpr.aggregate) { + return false; + } + // window exclusion cannot be handled by constant aggregates + if (wexpr.exclude_clause != WindowExcludeMode::NO_OTHER) { + return false; + } + + // DISTINCT aggregation cannot be handled by constant aggregation + // TODO: Use a hash table + if (wexpr.distinct) { + return false; + } + + // ORDER BY arguments cannot be handled by constant aggregation + if (!wexpr.arg_orders.empty()) { + return false; + } + + // COUNT(*) is already handled efficiently by segment trees. + if (wexpr.children.empty()) { + return false; + } + + /* + The default framing option is RANGE UNBOUNDED PRECEDING, which + is the same as RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT + ROW; it sets the frame to be all rows from the partition start + up through the current row's last peer (a row that the window's + ORDER BY clause considers equivalent to the current row; all + rows are peers if there is no ORDER BY). In general, UNBOUNDED + PRECEDING means that the frame starts with the first row of the + partition, and similarly UNBOUNDED FOLLOWING means that the + frame ends with the last row of the partition, regardless of + RANGE, ROWS or GROUPS mode. In ROWS mode, CURRENT ROW means that + the frame starts or ends with the current row; but in RANGE or + GROUPS mode it means that the frame starts or ends with the + current row's first or last peer in the ORDER BY ordering. The + offset PRECEDING and offset FOLLOWING options vary in meaning + depending on the frame mode. + */ + switch (wexpr.start) { + case WindowBoundary::UNBOUNDED_PRECEDING: + break; + case WindowBoundary::CURRENT_ROW_RANGE: + if (!wexpr.orders.empty()) { + return false; + } + break; + default: + return false; + } + + switch (wexpr.end) { + case WindowBoundary::UNBOUNDED_FOLLOWING: + break; + case WindowBoundary::CURRENT_ROW_RANGE: + if (!wexpr.orders.empty()) { + return false; + } + break; + default: + return false; + } + + return true; +} + +WindowConstantAggregator::WindowConstantAggregator(const BoundWindowExpression &wexpr, WindowSharedExpressions &shared) + : WindowAggregator(wexpr) { // We only need these values for Sink for (auto &child : wexpr.children) { diff --git a/src/duckdb/src/function/window/window_custom_aggregator.cpp b/src/duckdb/src/function/window/window_custom_aggregator.cpp index d75143524..8416e3031 100644 --- a/src/duckdb/src/function/window/window_custom_aggregator.cpp +++ b/src/duckdb/src/function/window/window_custom_aggregator.cpp @@ -1,13 +1,30 @@ #include "duckdb/function/window/window_custom_aggregator.hpp" +#include "duckdb/planner/expression/bound_window_expression.hpp" namespace duckdb { //===--------------------------------------------------------------------===// // WindowCustomAggregator //===--------------------------------------------------------------------===// -WindowCustomAggregator::WindowCustomAggregator(const BoundWindowExpression &wexpr, const WindowExcludeMode exclude_mode, - WindowSharedExpressions &shared) - : WindowAggregator(wexpr, exclude_mode, shared) { +bool WindowCustomAggregator::CanAggregate(const BoundWindowExpression &wexpr, WindowAggregationMode mode) { + if (!wexpr.aggregate) { + return false; + } + + if (!wexpr.aggregate->window) { + return false; + } + + // ORDER BY arguments are not currently supported + if (!wexpr.arg_orders.empty()) { + return false; + } + + return (mode < WindowAggregationMode::COMBINE); +} + +WindowCustomAggregator::WindowCustomAggregator(const BoundWindowExpression &wexpr, WindowSharedExpressions &shared) + : WindowAggregator(wexpr, shared) { } WindowCustomAggregator::~WindowCustomAggregator() { diff --git a/src/duckdb/src/function/window/window_distinct_aggregator.cpp b/src/duckdb/src/function/window/window_distinct_aggregator.cpp index ba466288f..1dc940f95 100644 --- a/src/duckdb/src/function/window/window_distinct_aggregator.cpp +++ b/src/duckdb/src/function/window/window_distinct_aggregator.cpp @@ -6,6 +6,7 @@ #include "duckdb/function/window/window_aggregate_states.hpp" #include "duckdb/planner/bound_result_modifier.hpp" #include "duckdb/planner/expression/bound_constant_expression.hpp" +#include "duckdb/planner/expression/bound_window_expression.hpp" #include #include @@ -15,10 +16,17 @@ namespace duckdb { //===--------------------------------------------------------------------===// // WindowDistinctAggregator //===--------------------------------------------------------------------===// -WindowDistinctAggregator::WindowDistinctAggregator(const BoundWindowExpression &wexpr, - const WindowExcludeMode exclude_mode_p, - WindowSharedExpressions &shared, ClientContext &context) - : WindowAggregator(wexpr, exclude_mode_p, shared), context(context) { +bool WindowDistinctAggregator::CanAggregate(const BoundWindowExpression &wexpr) { + if (!wexpr.aggregate) { + return false; + } + + return wexpr.distinct && wexpr.exclude_clause == WindowExcludeMode::NO_OTHER && wexpr.arg_orders.empty(); +} + +WindowDistinctAggregator::WindowDistinctAggregator(const BoundWindowExpression &wexpr, WindowSharedExpressions &shared, + ClientContext &context) + : WindowAggregator(wexpr, shared), context(context) { } class WindowDistinctAggregatorLocalState; diff --git a/src/duckdb/src/function/window/window_executor.cpp b/src/duckdb/src/function/window/window_executor.cpp index 40381f0e6..f4dab47af 100644 --- a/src/duckdb/src/function/window/window_executor.cpp +++ b/src/duckdb/src/function/window/window_executor.cpp @@ -47,6 +47,17 @@ WindowExecutor::WindowExecutor(BoundWindowExpression &wexpr, ClientContext &cont } } +void WindowExecutor::Evaluate(idx_t row_idx, DataChunk &eval_chunk, Vector &result, WindowExecutorLocalState &lstate, + WindowExecutorGlobalState &gstate) const { + auto &lbstate = lstate.Cast(); + lbstate.UpdateBounds(gstate, row_idx, eval_chunk, lstate.range_cursor); + + const auto count = eval_chunk.size(); + EvaluateInternal(gstate, lstate, eval_chunk, result, count, row_idx); + + result.Verify(count); +} + WindowExecutorGlobalState::WindowExecutorGlobalState(const WindowExecutor &executor, const idx_t payload_count, const ValidityMask &partition_mask, const ValidityMask &order_mask) : executor(executor), payload_count(payload_count), partition_mask(partition_mask), order_mask(order_mask) { diff --git a/src/duckdb/src/function/window/window_index_tree.cpp b/src/duckdb/src/function/window/window_index_tree.cpp index c71984f50..5791b2af7 100644 --- a/src/duckdb/src/function/window/window_index_tree.cpp +++ b/src/duckdb/src/function/window/window_index_tree.cpp @@ -56,7 +56,7 @@ idx_t WindowIndexTree::SelectNth(const SubFrames &frames, idx_t n) const { if (mst32) { return mst32->NthElement(mst32->SelectNth(frames, n)); } else { - return mst64->NthElement(mst32->SelectNth(frames, n)); + return mst64->NthElement(mst64->SelectNth(frames, n)); } } diff --git a/src/duckdb/src/function/window/window_merge_sort_tree.cpp b/src/duckdb/src/function/window/window_merge_sort_tree.cpp index b2d7db4d9..ef22694c4 100644 --- a/src/duckdb/src/function/window/window_merge_sort_tree.cpp +++ b/src/duckdb/src/function/window/window_merge_sort_tree.cpp @@ -11,8 +11,9 @@ WindowMergeSortTree::WindowMergeSortTree(ClientContext &context, const vector::max()) { + if (count < std::numeric_limits::max() && !force_external) { index_type = LogicalType::INTEGER; mst32 = make_uniq(); } else { @@ -40,7 +41,7 @@ WindowMergeSortTree::WindowMergeSortTree(ClientContext &context, const vector(buffer_manager, orders, payload_layout); } - global_sort->external = ClientConfig::GetConfig(context).force_external; + global_sort->external = force_external; } optional_ptr WindowMergeSortTree::AddLocalSort() { diff --git a/src/duckdb/src/function/window/window_naive_aggregator.cpp b/src/duckdb/src/function/window/window_naive_aggregator.cpp index 8bf0d54d3..448639e77 100644 --- a/src/duckdb/src/function/window/window_naive_aggregator.cpp +++ b/src/duckdb/src/function/window/window_naive_aggregator.cpp @@ -1,14 +1,21 @@ #include "duckdb/function/window/window_naive_aggregator.hpp" +#include "duckdb/common/sort/sort.hpp" #include "duckdb/function/window/window_collection.hpp" +#include "duckdb/function/window/window_shared_expressions.hpp" +#include "duckdb/planner/expression/bound_window_expression.hpp" +#include "duckdb/function/window/window_aggregate_function.hpp" namespace duckdb { //===--------------------------------------------------------------------===// // WindowNaiveAggregator //===--------------------------------------------------------------------===// -WindowNaiveAggregator::WindowNaiveAggregator(const BoundWindowExpression &wexpr, const WindowExcludeMode exclude_mode, - WindowSharedExpressions &shared) - : WindowAggregator(wexpr, exclude_mode, shared) { +WindowNaiveAggregator::WindowNaiveAggregator(const WindowAggregateExecutor &executor, WindowSharedExpressions &shared) + : WindowAggregator(executor.wexpr, shared), executor(executor) { + + for (const auto &order : wexpr.arg_orders) { + arg_order_idx.emplace_back(shared.RegisterCollection(order.expression, false)); + } } WindowNaiveAggregator::~WindowNaiveAggregator() { @@ -76,6 +83,17 @@ class WindowNaiveState : public WindowAggregatorLocalState { Vector hashes; //! The state used for comparing the collection across chunk boundaries unique_ptr comparer; + + //! The state used for scanning ORDER BY values from the collection + unique_ptr arg_orderer; + //! Reusable sort key chunk + DataChunk orderby_sort; + //! Reusable sort payload chunk + DataChunk orderby_payload; + //! Reusable sort key slicer + SelectionVector orderby_sel; + //! Reusable payload layout. + RowLayout payload_layout; }; WindowNaiveState::WindowNaiveState(const WindowNaiveAggregator &aggregator_p) @@ -95,6 +113,13 @@ WindowNaiveState::WindowNaiveState(const WindowNaiveAggregator &aggregator_p) fdata[i] = state_ptr; state_ptr += aggregator.state_size; } + + // Initialise any ORDER BY data + if (!aggregator.arg_order_idx.empty() && !arg_orderer) { + orderby_payload.Initialize(Allocator::DefaultAllocator(), {LogicalType::UBIGINT}); + payload_layout.Initialize(orderby_payload.GetTypes()); + orderby_sel.Initialize(); + } } void WindowNaiveState::Finalize(WindowAggregatorGlobalState &gastate, CollectionPtr collection) { @@ -102,7 +127,19 @@ void WindowNaiveState::Finalize(WindowAggregatorGlobalState &gastate, Collection // Set up the comparison scanner just in case if (!comparer) { - comparer = make_uniq(*collection, gastate.aggregator.child_idx); + comparer = make_uniq(*collection, aggregator.child_idx); + } + + // Set up the argument ORDER BY scanner if needed + if (!aggregator.arg_order_idx.empty() && !arg_orderer) { + arg_orderer = make_uniq(*collection, aggregator.arg_order_idx); + orderby_sort.Initialize(BufferAllocator::Get(gastate.context), arg_orderer->chunk.GetTypes()); + } + + // Initialise the chunks + const auto types = cursor->chunk.GetTypes(); + if (leaves.ColumnCount() == 0 && !types.empty()) { + leaves.Initialize(BufferAllocator::Get(gastate.context), types); } } @@ -175,10 +212,6 @@ void WindowNaiveState::Evaluate(const WindowAggregatorGlobalState &gsink, const auto &filter_mask = gsink.filter_mask; const auto types = cursor->chunk.GetTypes(); - if (leaves.ColumnCount() == 0 && !types.empty()) { - leaves.Initialize(Allocator::DefaultAllocator(), types); - } - auto fdata = FlatVector::GetData(statef); auto pdata = FlatVector::GetData(statep); @@ -190,8 +223,90 @@ void WindowNaiveState::Evaluate(const WindowAggregatorGlobalState &gsink, const auto agg_state = fdata[rid]; aggr.function.initialize(aggr.function, agg_state); - // Just update the aggregate with the unfiltered input rows + // Reset the DISTINCT hash table row_set.clear(); + + // Sort the input rows by the argument + if (arg_orderer) { + auto &context = aggregator.executor.context; + auto &orders = aggregator.wexpr.arg_orders; + auto &buffer_manager = BufferManager::GetBufferManager(context); + GlobalSortState global_sort(buffer_manager, orders, payload_layout); + LocalSortState local_sort; + local_sort.Initialize(global_sort, global_sort.buffer_manager); + + idx_t orderby_count = 0; + auto orderby_row = FlatVector::GetData(orderby_payload.data[0]); + for (const auto &frame : frames) { + for (auto f = frame.start; f < frame.end; ++f) { + // FILTER before the ORDER BY + if (!filter_mask.RowIsValid(f)) { + continue; + } + + if (!arg_orderer->RowIsVisible(f) || orderby_count >= STANDARD_VECTOR_SIZE) { + if (orderby_count) { + orderby_sort.Reference(arg_orderer->chunk); + orderby_sort.Slice(orderby_sel, orderby_count); + orderby_payload.SetCardinality(orderby_count); + local_sort.SinkChunk(orderby_sort, orderby_payload); + } + orderby_count = 0; + arg_orderer->Seek(f); + } + orderby_row[orderby_count] = f; + orderby_sel.set_index(orderby_count++, arg_orderer->RowOffset(f)); + } + } + if (orderby_count) { + orderby_sort.Reference(arg_orderer->chunk); + orderby_sort.Slice(orderby_sel, orderby_count); + orderby_payload.SetCardinality(orderby_count); + local_sort.SinkChunk(orderby_sort, orderby_payload); + } + + global_sort.AddLocalState(local_sort); + if (global_sort.sorted_blocks.empty()) { + return; + } + global_sort.PrepareMergePhase(); + while (global_sort.sorted_blocks.size() > 1) { + global_sort.InitializeMergeRound(); + MergeSorter merge_sorter(global_sort, global_sort.buffer_manager); + merge_sorter.PerformInMergeRound(); + global_sort.CompleteMergeRound(false); + } + + PayloadScanner scanner(global_sort); + while (scanner.Remaining()) { + orderby_payload.Reset(); + scanner.Scan(orderby_payload); + orderby_row = FlatVector::GetData(orderby_payload.data[0]); + for (idx_t i = 0; i < orderby_payload.size(); ++i) { + const auto f = orderby_row[i]; + // Seek to the current position + if (!cursor->RowIsVisible(f)) { + // We need to flush when we cross a chunk boundary + FlushStates(gsink); + cursor->Seek(f); + } + + // Filter out duplicates + if (aggr.IsDistinct() && !row_set.insert(f).second) { + continue; + } + + pdata[flush_count] = agg_state; + update_sel[flush_count++] = cursor->RowOffset(f); + if (flush_count >= STANDARD_VECTOR_SIZE) { + FlushStates(gsink); + } + } + } + return; + } + + // Just update the aggregate with the unfiltered input rows for (const auto &frame : frames) { for (auto f = frame.start; f < frame.end; ++f) { if (!filter_mask.RowIsValid(f)) { diff --git a/src/duckdb/src/function/window/window_segment_tree.cpp b/src/duckdb/src/function/window/window_segment_tree.cpp index 0ccc8615b..6708ae90b 100644 --- a/src/duckdb/src/function/window/window_segment_tree.cpp +++ b/src/duckdb/src/function/window/window_segment_tree.cpp @@ -10,6 +10,18 @@ namespace duckdb { //===--------------------------------------------------------------------===// // WindowSegmentTree //===--------------------------------------------------------------------===// +bool WindowSegmentTree::CanAggregate(const BoundWindowExpression &wexpr) { + if (!wexpr.aggregate) { + return false; + } + + return !wexpr.distinct && wexpr.arg_orders.empty(); +} + +WindowSegmentTree::WindowSegmentTree(const BoundWindowExpression &wexpr, WindowSharedExpressions &shared) + : WindowAggregator(wexpr, shared) { +} + class WindowSegmentTreeGlobalState : public WindowAggregatorGlobalState { public: using AtomicCounters = vector>; @@ -43,11 +55,6 @@ class WindowSegmentTreeGlobalState : public WindowAggregatorGlobalState { static constexpr idx_t TREE_FANOUT = 16; }; -WindowSegmentTree::WindowSegmentTree(const BoundWindowExpression &wexpr, WindowAggregationMode mode_p, - const WindowExcludeMode exclude_mode_p, WindowSharedExpressions &shared) - : WindowAggregator(wexpr, exclude_mode_p, shared), mode(mode_p) { -} - class WindowSegmentTreePart { public: //! Right side nodes need to be cached and processed in reverse order diff --git a/src/duckdb/src/include/duckdb.h b/src/duckdb/src/include/duckdb.h index 5efd2bd6b..ae52abd33 100644 --- a/src/duckdb/src/include/duckdb.h +++ b/src/duckdb/src/include/duckdb.h @@ -441,7 +441,12 @@ typedef struct { void *internal_data; } duckdb_result; -//! A database object. Should be closed with `duckdb_close`. +//! A database instance cache object. Must be destroyed with `duckdb_destroy_instance_cache`. +typedef struct _duckdb_instance_cache { + void *internal_ptr; +} * duckdb_instance_cache; + +//! A database object. Must be closed with `duckdb_close`. typedef struct _duckdb_database { void *internal_ptr; } * duckdb_database; @@ -680,12 +685,44 @@ struct duckdb_extension_access { // Open Connect //===--------------------------------------------------------------------===// +/*! +Creates a new database instance cache. +The instance cache is necessary if a client/program (re)opens multiple databases to the same file within the same +process. Must be destroyed with 'duckdb_destroy_instance_cache'. + +* @return The database instance cache. +*/ +DUCKDB_API duckdb_instance_cache duckdb_create_instance_cache(); + +/*! +Creates a new database instance in the instance cache, or retrieves an existing database instance. +Must be closed with 'duckdb_close'. + +* @param instance_cache The instance cache in which to create the database, or from which to take the database. +* @param path Path to the database file on disk. Both `nullptr` and `:memory:` open or retrieve an in-memory database. +* @param out_database The resulting cached database. +* @param config (Optional) configuration used to create the database. +* @param out_error If set and the function returns `DuckDBError`, this contains the error message. +Note that the error message must be freed using `duckdb_free`. +* @return `DuckDBSuccess` on success or `DuckDBError` on failure. +*/ +DUCKDB_API duckdb_state duckdb_get_or_create_from_cache(duckdb_instance_cache instance_cache, const char *path, + duckdb_database *out_database, duckdb_config config, + char **out_error); + +/*! +Destroys an existing database instance cache and de-allocates its memory. + +* @param instance_cache The instance cache to destroy. +*/ +DUCKDB_API void duckdb_destroy_instance_cache(duckdb_instance_cache *instance_cache); + /*! Creates a new database or opens an existing database file stored at the given path. If no path is given a new in-memory database is created instead. -The instantiated database should be closed with 'duckdb_close'. +The database must be closed with 'duckdb_close'. -* @param path Path to the database file on disk, or `nullptr` or `:memory:` to open an in-memory database. +* @param path Path to the database file on disk. Both `nullptr` and `:memory:` open an in-memory database. * @param out_database The result database object. * @return `DuckDBSuccess` on success or `DuckDBError` on failure. */ @@ -693,13 +730,13 @@ DUCKDB_API duckdb_state duckdb_open(const char *path, duckdb_database *out_datab /*! Extended version of duckdb_open. Creates a new database or opens an existing database file stored at the given path. -The instantiated database should be closed with 'duckdb_close'. +The database must be closed with 'duckdb_close'. -* @param path Path to the database file on disk, or `nullptr` or `:memory:` to open an in-memory database. +* @param path Path to the database file on disk. Both `nullptr` and `:memory:` open an in-memory database. * @param out_database The result database object. -* @param config (Optional) configuration used to start up the database system. -* @param out_error If set and the function returns DuckDBError, this will contain the reason why the start-up failed. -Note that the error must be freed using `duckdb_free`. +* @param config (Optional) configuration used to start up the database. +* @param out_error If set and the function returns `DuckDBError`, this contains the error message. +Note that the error message must be freed using `duckdb_free`. * @return `DuckDBSuccess` on success or `DuckDBError` on failure. */ DUCKDB_API duckdb_state duckdb_open_ext(const char *path, duckdb_database *out_database, duckdb_config config, diff --git a/src/duckdb/src/include/duckdb/common/enum_util.hpp b/src/duckdb/src/include/duckdb/common/enum_util.hpp index 6057a89b2..852f43436 100644 --- a/src/duckdb/src/include/duckdb/common/enum_util.hpp +++ b/src/duckdb/src/include/duckdb/common/enum_util.hpp @@ -102,6 +102,8 @@ enum class CompressedMaterializationDirection : uint8_t; enum class CompressionType : uint8_t; +enum class CompressionValidity : uint8_t; + enum class ConflictManagerMode : uint8_t; enum class ConstraintType : uint8_t; @@ -114,6 +116,8 @@ enum class CopyToType : uint8_t; enum class DataFileType : uint8_t; +enum class DateCastResult : uint8_t; + enum class DatePartSpecifier : uint8_t; enum class DebugInitialize : uint8_t; @@ -484,6 +488,9 @@ const char* EnumUtil::ToChars(CompressedMate template<> const char* EnumUtil::ToChars(CompressionType value); +template<> +const char* EnumUtil::ToChars(CompressionValidity value); + template<> const char* EnumUtil::ToChars(ConflictManagerMode value); @@ -502,6 +509,9 @@ const char* EnumUtil::ToChars(CopyToType value); template<> const char* EnumUtil::ToChars(DataFileType value); +template<> +const char* EnumUtil::ToChars(DateCastResult value); + template<> const char* EnumUtil::ToChars(DatePartSpecifier value); @@ -1004,6 +1014,9 @@ CompressedMaterializationDirection EnumUtil::FromString CompressionType EnumUtil::FromString(const char *value); +template<> +CompressionValidity EnumUtil::FromString(const char *value); + template<> ConflictManagerMode EnumUtil::FromString(const char *value); @@ -1022,6 +1035,9 @@ CopyToType EnumUtil::FromString(const char *value); template<> DataFileType EnumUtil::FromString(const char *value); +template<> +DateCastResult EnumUtil::FromString(const char *value); + template<> DatePartSpecifier EnumUtil::FromString(const char *value); 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 6a1c30d42..a8753f12b 100644 --- a/src/duckdb/src/include/duckdb/common/enums/compression_type.hpp +++ b/src/duckdb/src/include/duckdb/common/enums/compression_type.hpp @@ -16,7 +16,7 @@ namespace duckdb { enum class CompressionType : uint8_t { COMPRESSION_AUTO = 0, COMPRESSION_UNCOMPRESSED = 1, - COMPRESSION_CONSTANT = 2, + COMPRESSION_CONSTANT = 2, // internal only COMPRESSION_RLE = 3, COMPRESSION_DICTIONARY = 4, COMPRESSION_PFOR_DELTA = 5, @@ -28,7 +28,8 @@ enum class CompressionType : uint8_t { COMPRESSION_ALPRD = 11, COMPRESSION_ZSTD = 12, COMPRESSION_ROARING = 13, - COMPRESSION_COUNT // This has to stay the last entry of the type! + COMPRESSION_EMPTY = 14, // internal only + COMPRESSION_COUNT // This has to stay the last entry of the type! }; bool CompressionTypeIsDeprecated(CompressionType compression_type); 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 fe4e02ad8..c2d38152a 100644 --- a/src/duckdb/src/include/duckdb/common/local_file_system.hpp +++ b/src/duckdb/src/include/duckdb/common/local_file_system.hpp @@ -96,6 +96,9 @@ class LocalFileSystem : public FileSystem { //! Checks a file is private (checks for 600 on linux/macos, TODO: currently always returns true on windows) static bool IsPrivateFile(const string &path_p, FileOpener *opener); + // returns a C-string of the path that trims any file:/ prefix + static const char *NormalizeLocalPath(const string &path); + 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); diff --git a/src/duckdb/src/include/duckdb/common/types/date.hpp b/src/duckdb/src/include/duckdb/common/types/date.hpp index f2cb08d50..ea6b52ce7 100644 --- a/src/duckdb/src/include/duckdb/common/types/date.hpp +++ b/src/duckdb/src/include/duckdb/common/types/date.hpp @@ -83,6 +83,8 @@ struct date_t { // NOLINT } // NOLINT }; +enum class DateCastResult : uint8_t { SUCCESS, ERROR_INCORRECT_FORMAT, ERROR_RANGE }; + //! The Date class is a static class that holds helper functions for the Date type. class Date { public: @@ -127,8 +129,8 @@ class Date { DUCKDB_API static bool TryConvertDateSpecial(const char *buf, idx_t len, idx_t &pos, const char *special); //! Try to convert text in a buffer to a date; returns true if parsing was successful //! If the date was a "special" value, the special flag will be set. - DUCKDB_API static bool TryConvertDate(const char *buf, idx_t len, idx_t &pos, date_t &result, bool &special, - bool strict = false); + DUCKDB_API static DateCastResult TryConvertDate(const char *buf, idx_t len, idx_t &pos, date_t &result, + bool &special, bool strict = false); //! Create a string "YYYY-MM-DD" from a specified (year, month, day) //! combination @@ -202,8 +204,11 @@ class Date { //! Helper function to parse two digits from a string (e.g. "30" -> 30, "03" -> 3, "3" -> 3) DUCKDB_API static bool ParseDoubleDigit(const char *buf, idx_t len, idx_t &pos, int32_t &result); - DUCKDB_API static string ConversionError(const string &str); - DUCKDB_API static string ConversionError(string_t str); + DUCKDB_API static string FormatError(const string &str); + DUCKDB_API static string FormatError(string_t str); + + DUCKDB_API static string RangeError(const string &str); + DUCKDB_API static string RangeError(string_t str); private: static void ExtractYearOffset(int32_t &n, int32_t &year, int32_t &year_offset); diff --git a/src/duckdb/src/include/duckdb/common/types/timestamp.hpp b/src/duckdb/src/include/duckdb/common/types/timestamp.hpp index eaab803e8..c56168251 100644 --- a/src/duckdb/src/include/duckdb/common/types/timestamp.hpp +++ b/src/duckdb/src/include/duckdb/common/types/timestamp.hpp @@ -112,7 +112,7 @@ struct timestamp_tz_t : public timestamp_t { // NOLINT } }; -enum class TimestampCastResult : uint8_t { SUCCESS, ERROR_INCORRECT_FORMAT, ERROR_NON_UTC_TIMEZONE }; +enum class TimestampCastResult : uint8_t { SUCCESS, ERROR_INCORRECT_FORMAT, ERROR_NON_UTC_TIMEZONE, ERROR_RANGE }; //! The static Timestamp class holds helper functions for the timestamp types. class Timestamp { @@ -128,8 +128,9 @@ class Timestamp { //! Convert a string where the offset can also be a time zone string: / [A_Za-z0-9/_]+/ //! If has_offset is true, then the result is an instant that was offset from UTC //! If the tz is not empty, the result is still an instant, but the parts can be extracted and applied to the TZ - DUCKDB_API static bool TryConvertTimestampTZ(const char *str, idx_t len, timestamp_t &result, bool &has_offset, - string_t &tz, optional_ptr nanos = nullptr); + DUCKDB_API static TimestampCastResult TryConvertTimestampTZ(const char *str, idx_t len, timestamp_t &result, + bool &has_offset, string_t &tz, + optional_ptr nanos = nullptr); DUCKDB_API static TimestampCastResult TryConvertTimestamp(const char *str, idx_t len, timestamp_t &result, optional_ptr nanos = nullptr); DUCKDB_API static TimestampCastResult TryConvertTimestamp(const char *str, idx_t len, timestamp_ns_t &result); @@ -200,10 +201,12 @@ class Timestamp { DUCKDB_API static bool TryParseUTCOffset(const char *str, idx_t &pos, idx_t len, int &hour_offset, int &minute_offset); - DUCKDB_API static string ConversionError(const string &str); - DUCKDB_API static string ConversionError(string_t str); + DUCKDB_API static string FormatError(const string &str); + DUCKDB_API static string FormatError(string_t str); DUCKDB_API static string UnsupportedTimezoneError(const string &str); DUCKDB_API static string UnsupportedTimezoneError(string_t str); + DUCKDB_API static string RangeError(const string &str); + DUCKDB_API static string RangeError(string_t str); }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/function/compression/compression.hpp b/src/duckdb/src/include/duckdb/function/compression/compression.hpp index 28113c78e..adf5364b7 100644 --- a/src/duckdb/src/include/duckdb/function/compression/compression.hpp +++ b/src/duckdb/src/include/duckdb/function/compression/compression.hpp @@ -73,4 +73,9 @@ struct RoaringCompressionFun { static bool TypeIsSupported(const PhysicalType physical_type); }; +struct EmptyValidityCompressionFun { + static CompressionFunction GetFunction(PhysicalType type); + static bool TypeIsSupported(const PhysicalType physical_type); +}; + } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/function/compression_function.hpp b/src/duckdb/src/include/duckdb/function/compression_function.hpp index d11beaa72..b0546a5a2 100644 --- a/src/duckdb/src/include/duckdb/function/compression_function.hpp +++ b/src/duckdb/src/include/duckdb/function/compression_function.hpp @@ -203,6 +203,8 @@ typedef unique_ptr (*compression_deserialize_state_t)(Deseri //! Function prototype for cleaning up the segment state when the column data is dropped typedef void (*compression_cleanup_state_t)(ColumnSegment &segment); +enum class CompressionValidity : uint8_t { REQUIRES_VALIDITY, NO_VALIDITY_REQUIRED }; + class CompressionFunction { public: CompressionFunction(CompressionType type, PhysicalType data_type, compression_init_analyze_t init_analyze, @@ -297,6 +299,10 @@ class CompressionFunction { compression_deserialize_state_t deserialize_state; //! Cleanup the segment state (optional) compression_cleanup_state_t cleanup_state; + + //! Whether the validity mask should be separately compressed + //! or this compression function can also be used to decompress the validity + CompressionValidity validity = CompressionValidity::REQUIRES_VALIDITY; }; //! The set of compression functions diff --git a/src/duckdb/src/include/duckdb/function/window/window_aggregate_function.hpp b/src/duckdb/src/include/duckdb/function/window/window_aggregate_function.hpp index b110315cd..efc782b8c 100644 --- a/src/duckdb/src/include/duckdb/function/window/window_aggregate_function.hpp +++ b/src/duckdb/src/include/duckdb/function/window/window_aggregate_function.hpp @@ -6,6 +6,8 @@ // //===----------------------------------------------------------------------===// +#pragma once + #include "duckdb/function/window/window_executor.hpp" #include "duckdb/common/enums/window_aggregation_mode.hpp" #include "duckdb/function/window/window_aggregator.hpp" @@ -17,10 +19,6 @@ class WindowAggregateExecutor : public WindowExecutor { WindowAggregateExecutor(BoundWindowExpression &wexpr, ClientContext &context, WindowSharedExpressions &shared, WindowAggregationMode mode); - bool IsConstantAggregate(); - bool IsCustomAggregate(); - bool IsDistinctAggregate(); - void Sink(DataChunk &sink_chunk, DataChunk &coll_chunk, const idx_t input_idx, WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate) const override; void Finalize(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate, diff --git a/src/duckdb/src/include/duckdb/function/window/window_aggregator.hpp b/src/duckdb/src/include/duckdb/function/window/window_aggregator.hpp index c7103ce41..1caa6326d 100644 --- a/src/duckdb/src/include/duckdb/function/window/window_aggregator.hpp +++ b/src/duckdb/src/include/duckdb/function/window/window_aggregator.hpp @@ -105,9 +105,8 @@ class WindowAggregator { } } - WindowAggregator(const BoundWindowExpression &wexpr, const WindowExcludeMode exclude_mode_p); - WindowAggregator(const BoundWindowExpression &wexpr, const WindowExcludeMode exclude_mode_p, - WindowSharedExpressions &shared); + explicit WindowAggregator(const BoundWindowExpression &wexpr); + WindowAggregator(const BoundWindowExpression &wexpr, WindowSharedExpressions &shared); virtual ~WindowAggregator(); // Threading states @@ -144,7 +143,7 @@ class WindowAggregator { class WindowAggregatorGlobalState : public WindowAggregatorState { public: WindowAggregatorGlobalState(ClientContext &context, const WindowAggregator &aggregator_p, idx_t group_count) - : aggregator(aggregator_p), aggr(aggregator.wexpr), locals(0), finalized(0) { + : context(context), aggregator(aggregator_p), aggr(aggregator.wexpr), locals(0), finalized(0) { if (aggr.filter) { // Start with all invalid and set the ones that pass @@ -154,6 +153,9 @@ class WindowAggregatorGlobalState : public WindowAggregatorState { } } + //! The context we are in + ClientContext &context; + //! The aggregator data const WindowAggregator &aggregator; diff --git a/src/duckdb/src/include/duckdb/function/window/window_constant_aggregator.hpp b/src/duckdb/src/include/duckdb/function/window/window_constant_aggregator.hpp index af3c7f88c..fdf07cc7a 100644 --- a/src/duckdb/src/include/duckdb/function/window/window_constant_aggregator.hpp +++ b/src/duckdb/src/include/duckdb/function/window/window_constant_aggregator.hpp @@ -14,8 +14,9 @@ namespace duckdb { class WindowConstantAggregator : public WindowAggregator { public: - WindowConstantAggregator(const BoundWindowExpression &wexpr, WindowExcludeMode exclude_mode_p, - WindowSharedExpressions &shared); + static bool CanAggregate(const BoundWindowExpression &wexpr); + + WindowConstantAggregator(const BoundWindowExpression &wexpr, WindowSharedExpressions &shared); ~WindowConstantAggregator() override { } diff --git a/src/duckdb/src/include/duckdb/function/window/window_custom_aggregator.hpp b/src/duckdb/src/include/duckdb/function/window/window_custom_aggregator.hpp index dffad8483..ab664ca59 100644 --- a/src/duckdb/src/include/duckdb/function/window/window_custom_aggregator.hpp +++ b/src/duckdb/src/include/duckdb/function/window/window_custom_aggregator.hpp @@ -14,8 +14,9 @@ namespace duckdb { class WindowCustomAggregator : public WindowAggregator { public: - WindowCustomAggregator(const BoundWindowExpression &wexpr, const WindowExcludeMode exclude_mode, - WindowSharedExpressions &shared); + static bool CanAggregate(const BoundWindowExpression &wexpr, WindowAggregationMode mode); + + WindowCustomAggregator(const BoundWindowExpression &wexpr, WindowSharedExpressions &shared); ~WindowCustomAggregator() override; unique_ptr GetGlobalState(ClientContext &context, idx_t group_count, diff --git a/src/duckdb/src/include/duckdb/function/window/window_distinct_aggregator.hpp b/src/duckdb/src/include/duckdb/function/window/window_distinct_aggregator.hpp index 1cafc9252..7fe9040c0 100644 --- a/src/duckdb/src/include/duckdb/function/window/window_distinct_aggregator.hpp +++ b/src/duckdb/src/include/duckdb/function/window/window_distinct_aggregator.hpp @@ -14,8 +14,10 @@ namespace duckdb { class WindowDistinctAggregator : public WindowAggregator { public: - WindowDistinctAggregator(const BoundWindowExpression &wexpr, const WindowExcludeMode exclude_mode_p, - WindowSharedExpressions &shared, ClientContext &context); + static bool CanAggregate(const BoundWindowExpression &wexpr); + + WindowDistinctAggregator(const BoundWindowExpression &wexpr, WindowSharedExpressions &shared, + ClientContext &context); // Build unique_ptr GetGlobalState(ClientContext &context, idx_t group_count, diff --git a/src/duckdb/src/include/duckdb/function/window/window_naive_aggregator.hpp b/src/duckdb/src/include/duckdb/function/window/window_naive_aggregator.hpp index 199301bb4..1fdf497ee 100644 --- a/src/duckdb/src/include/duckdb/function/window/window_naive_aggregator.hpp +++ b/src/duckdb/src/include/duckdb/function/window/window_naive_aggregator.hpp @@ -12,16 +12,22 @@ namespace duckdb { +class WindowAggregateExecutor; + // Used for validation class WindowNaiveAggregator : public WindowAggregator { public: - WindowNaiveAggregator(const BoundWindowExpression &wexpr, const WindowExcludeMode exclude_mode, - WindowSharedExpressions &shared); + WindowNaiveAggregator(const WindowAggregateExecutor &executor, WindowSharedExpressions &shared); ~WindowNaiveAggregator() override; unique_ptr GetLocalState(const WindowAggregatorState &gstate) const override; void Evaluate(const WindowAggregatorState &gsink, WindowAggregatorState &lstate, const DataChunk &bounds, Vector &result, idx_t count, idx_t row_idx) const override; + + //! The parent executor + const WindowAggregateExecutor &executor; + //! The column indices of any ORDER BY argument expressions + vector arg_order_idx; }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/function/window/window_segment_tree.hpp b/src/duckdb/src/include/duckdb/function/window/window_segment_tree.hpp index f3a7b6f96..0b574b959 100644 --- a/src/duckdb/src/include/duckdb/function/window/window_segment_tree.hpp +++ b/src/duckdb/src/include/duckdb/function/window/window_segment_tree.hpp @@ -13,10 +13,10 @@ namespace duckdb { class WindowSegmentTree : public WindowAggregator { - public: - WindowSegmentTree(const BoundWindowExpression &wexpr, WindowAggregationMode mode_p, - const WindowExcludeMode exclude_mode, WindowSharedExpressions &shared); + static bool CanAggregate(const BoundWindowExpression &wexpr); + + WindowSegmentTree(const BoundWindowExpression &wexpr, WindowSharedExpressions &shared); unique_ptr GetGlobalState(ClientContext &context, idx_t group_count, const ValidityMask &partition_mask) const override; @@ -26,15 +26,6 @@ class WindowSegmentTree : public WindowAggregator { void Evaluate(const WindowAggregatorState &gstate, WindowAggregatorState &lstate, const DataChunk &bounds, Vector &result, idx_t count, idx_t row_idx) const override; - -public: - //! Use the combine API, if available - inline bool UseCombineAPI() const { - return mode < WindowAggregationMode::SEPARATE; - } - - //! Use the combine API, if available - WindowAggregationMode mode; }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/main/capi/capi_internal.hpp b/src/duckdb/src/include/duckdb/main/capi/capi_internal.hpp index f2d825f29..c00425420 100644 --- a/src/duckdb/src/include/duckdb/main/capi/capi_internal.hpp +++ b/src/duckdb/src/include/duckdb/main/capi/capi_internal.hpp @@ -16,6 +16,7 @@ #include "duckdb/common/case_insensitive_map.hpp" #include "duckdb/main/client_context.hpp" #include "duckdb/planner/expression/bound_parameter_data.hpp" +#include "duckdb/main/db_instance_cache.hpp" #include #include @@ -28,8 +29,12 @@ namespace duckdb { -struct DatabaseData { - unique_ptr database; +struct DBInstanceCacheWrapper { + unique_ptr instance_cache; +}; + +struct DatabaseWrapper { + shared_ptr database; }; struct PreparedStatementWrapper { diff --git a/src/duckdb/src/include/duckdb/main/capi/extension_api.hpp b/src/duckdb/src/include/duckdb/main/capi/extension_api.hpp index 6a8bb4bca..71e6d18bc 100644 --- a/src/duckdb/src/include/duckdb/main/capi/extension_api.hpp +++ b/src/duckdb/src/include/duckdb/main/capi/extension_api.hpp @@ -460,6 +460,13 @@ typedef struct { duckdb_arrow_schema arrow_schema, duckdb_arrow_array arrow_array, duckdb_arrow_stream *out_stream); duckdb_data_chunk (*duckdb_stream_fetch_chunk)(duckdb_result result); + // Exposing the instance cache + + duckdb_instance_cache (*duckdb_create_instance_cache)(); + duckdb_state (*duckdb_get_or_create_from_cache)(duckdb_instance_cache instance_cache, const char *path, + duckdb_database *out_database, duckdb_config config, + char **out_error); + void (*duckdb_destroy_instance_cache)(duckdb_instance_cache *instance_cache); // New append functions that are added duckdb_state (*duckdb_append_default_to_chunk)(duckdb_appender appender, duckdb_data_chunk chunk, idx_t col, @@ -875,6 +882,9 @@ inline duckdb_ext_api_v1 CreateAPIv1() { result.duckdb_arrow_scan = duckdb_arrow_scan; result.duckdb_arrow_array_scan = duckdb_arrow_array_scan; result.duckdb_stream_fetch_chunk = duckdb_stream_fetch_chunk; + result.duckdb_create_instance_cache = duckdb_create_instance_cache; + result.duckdb_get_or_create_from_cache = duckdb_get_or_create_from_cache; + result.duckdb_destroy_instance_cache = duckdb_destroy_instance_cache; result.duckdb_append_default_to_chunk = duckdb_append_default_to_chunk; return result; } diff --git a/src/duckdb/src/include/duckdb/planner/expression/bound_window_expression.hpp b/src/duckdb/src/include/duckdb/planner/expression/bound_window_expression.hpp index adf15ead3..acd76a42f 100644 --- a/src/duckdb/src/include/duckdb/planner/expression/bound_window_expression.hpp +++ b/src/duckdb/src/include/duckdb/planner/expression/bound_window_expression.hpp @@ -73,6 +73,7 @@ class BoundWindowExpression : public Expression { string ToString() const override; //! The number of ordering clauses the functions share + static idx_t GetSharedOrders(const vector &lhs, const vector &rhs); idx_t GetSharedOrders(const BoundWindowExpression &other) const; bool PartitionsAreEquivalent(const BoundWindowExpression &other) const; diff --git a/src/duckdb/src/include/duckdb/planner/expression_binder/index_binder.hpp b/src/duckdb/src/include/duckdb/planner/expression_binder/index_binder.hpp index b15948b34..f8972d13e 100644 --- a/src/duckdb/src/include/duckdb/planner/expression_binder/index_binder.hpp +++ b/src/duckdb/src/include/duckdb/planner/expression_binder/index_binder.hpp @@ -30,6 +30,8 @@ class IndexBinder : public ExpressionBinder { TableCatalogEntry &table_entry, unique_ptr plan, unique_ptr alter_table_info); + static void InitCreateIndexInfo(LogicalGet &get, CreateIndexInfo &info, const string &schema); + protected: BindResult BindExpression(unique_ptr &expr_ptr, idx_t depth, bool root_expression = false) override; diff --git a/src/duckdb/src/include/duckdb/storage/compression/empty_validity.hpp b/src/duckdb/src/include/duckdb/storage/compression/empty_validity.hpp new file mode 100644 index 000000000..89abe1ce7 --- /dev/null +++ b/src/duckdb/src/include/duckdb/storage/compression/empty_validity.hpp @@ -0,0 +1,100 @@ +#pragma once + +#include "duckdb/function/compression_function.hpp" +#include "duckdb/storage/table/column_data.hpp" +#include "duckdb/storage/table/scan_state.hpp" +#include "duckdb/storage/table/column_data_checkpointer.hpp" + +namespace duckdb { + +class EmptyValidityCompression { +public: + struct EmptyValidityCompressionState : public CompressionState { + public: + explicit EmptyValidityCompressionState(ColumnDataCheckpointData &checkpoint_data, const CompressionInfo &info) + : CompressionState(info), + function(checkpoint_data.GetCompressionFunction(CompressionType::COMPRESSION_EMPTY)), + checkpoint_data(checkpoint_data) { + } + ~EmptyValidityCompressionState() override { + } + + public: + optional_ptr function; + ColumnDataCheckpointData &checkpoint_data; + idx_t count = 0; + idx_t non_nulls = 0; + }; + struct EmptyValiditySegmentScanState : public SegmentScanState { + EmptyValiditySegmentScanState() { + } + }; + +public: + static CompressionFunction CreateFunction() { + return CompressionFunction(CompressionType::COMPRESSION_EMPTY, PhysicalType::BIT, nullptr, nullptr, nullptr, + InitCompression, Compress, FinalizeCompress, InitScan, Scan, ScanPartial, FetchRow, + Skip, InitSegment); + } + +public: + static unique_ptr InitCompression(ColumnDataCheckpointData &checkpoint_data, + unique_ptr state_p) { + return make_uniq(checkpoint_data, state_p->info); + } + static void Compress(CompressionState &state_p, Vector &scan_vector, idx_t count) { + auto &state = state_p.Cast(); + UnifiedVectorFormat format; + scan_vector.ToUnifiedFormat(count, format); + state.non_nulls += format.validity.CountValid(count); + state.count += count; + } + static void FinalizeCompress(CompressionState &state_p) { + auto &state = state_p.Cast(); + auto &checkpoint_data = state.checkpoint_data; + + auto &db = checkpoint_data.GetDatabase(); + auto &type = checkpoint_data.GetType(); + auto row_start = checkpoint_data.GetRowGroup().start; + + auto &info = state.info; + auto compressed_segment = ColumnSegment::CreateTransientSegment(db, *state.function, type, row_start, + info.GetBlockSize(), info.GetBlockSize()); + compressed_segment->count = state.count; + if (state.non_nulls != state.count) { + compressed_segment->stats.statistics.SetHasNullFast(); + } + if (state.non_nulls != 0) { + compressed_segment->stats.statistics.SetHasNoNullFast(); + } + + auto &buffer_manager = BufferManager::GetBufferManager(checkpoint_data.GetDatabase()); + auto handle = buffer_manager.Pin(compressed_segment->block); + + auto &checkpoint_state = checkpoint_data.GetCheckpointState(); + checkpoint_state.FlushSegment(std::move(compressed_segment), std::move(handle), 0); + } + static unique_ptr InitScan(ColumnSegment &segment) { + return make_uniq(); + } + static void ScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result, + idx_t result_offset) { + return; + } + static void Scan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result) { + return; + } + static void FetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result, + idx_t result_idx) { + return; + } + static void Skip(ColumnSegment &segment, ColumnScanState &state, idx_t skip_count) { + return; + } + static unique_ptr InitSegment(ColumnSegment &segment, block_id_t block_id, + optional_ptr segment_state) { + return nullptr; + } +}; + +} // namespace duckdb 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 cbf354f37..adb3ed056 100644 --- a/src/duckdb/src/include/duckdb/storage/table/column_data.hpp +++ b/src/duckdb/src/include/duckdb/storage/table/column_data.hpp @@ -99,6 +99,7 @@ class ColumnData { const LogicalType &RootType() const; //! Whether or not the column has any updates bool HasUpdates() const; + bool HasChanges(idx_t start_row, idx_t end_row) const; //! Whether or not we can scan an entire vector virtual ScanVectorType GetVectorScanType(ColumnScanState &state, idx_t scan_count, Vector &result); diff --git a/src/duckdb/src/include/duckdb/storage/table/column_data_checkpointer.hpp b/src/duckdb/src/include/duckdb/storage/table/column_data_checkpointer.hpp index a5bd436bb..0db0e6fbc 100644 --- a/src/duckdb/src/include/duckdb/storage/table/column_data_checkpointer.hpp +++ b/src/duckdb/src/include/duckdb/storage/table/column_data_checkpointer.hpp @@ -74,6 +74,7 @@ class ColumnDataCheckpointer { void WritePersistentSegments(ColumnCheckpointState &state); void InitAnalyze(); void DropSegments(); + bool ValidityCoveredByBasedata(vector &result); private: vector> &checkpoint_states; diff --git a/src/duckdb/src/include/duckdb_extension.h b/src/duckdb/src/include/duckdb_extension.h index 5eca823d5..47c6a7f87 100644 --- a/src/duckdb/src/include/duckdb_extension.h +++ b/src/duckdb/src/include/duckdb_extension.h @@ -527,6 +527,15 @@ typedef struct { duckdb_data_chunk (*duckdb_stream_fetch_chunk)(duckdb_result result); #endif +// Exposing the instance cache +#ifdef DUCKDB_EXTENSION_API_VERSION_UNSTABLE + duckdb_instance_cache (*duckdb_create_instance_cache)(); + duckdb_state (*duckdb_get_or_create_from_cache)(duckdb_instance_cache instance_cache, const char *path, + duckdb_database *out_database, duckdb_config config, + char **out_error); + void (*duckdb_destroy_instance_cache)(duckdb_instance_cache *instance_cache); +#endif + // New append functions that are added #ifdef DUCKDB_EXTENSION_API_VERSION_UNSTABLE duckdb_state (*duckdb_append_default_to_chunk)(duckdb_appender appender, duckdb_data_chunk chunk, idx_t col, @@ -947,6 +956,11 @@ typedef struct { #define duckdb_arrow_array_scan duckdb_ext_api.duckdb_arrow_array_scan #define duckdb_stream_fetch_chunk duckdb_ext_api.duckdb_stream_fetch_chunk +// Version unstable_instance_cache +#define duckdb_create_instance_cache duckdb_ext_api.duckdb_create_instance_cache +#define duckdb_get_or_create_from_cache duckdb_ext_api.duckdb_get_or_create_from_cache +#define duckdb_destroy_instance_cache duckdb_ext_api.duckdb_destroy_instance_cache + // Version unstable_new_append_functions #define duckdb_append_default_to_chunk duckdb_ext_api.duckdb_append_default_to_chunk @@ -966,6 +980,12 @@ typedef struct { // Place in global scope of any C/C++ file that needs to access the extension API #define DUCKDB_EXTENSION_EXTERN extern duckdb_ext_api_v1 duckdb_ext_api; +#ifdef _WIN32 +#define DUCKDB_CAPI_ENTRY_VISIBILITY __declspec(dllexport) +#else +#define DUCKDB_CAPI_ENTRY_VISIBILITY __attribute__((visibility("default"))) +#endif + //===--------------------------------------------------------------------===// // Entrypoint Macros //===--------------------------------------------------------------------===// @@ -979,7 +999,7 @@ typedef struct { #define DUCKDB_EXTENSION_ENTRYPOINT \ DUCKDB_EXTENSION_GLOBAL static bool DUCKDB_EXTENSION_GLUE(DUCKDB_EXTENSION_NAME, _init_c_api_internal)( \ duckdb_connection connection, duckdb_extension_info info, struct duckdb_extension_access * access); \ - DUCKDB_EXTENSION_EXTERN_C_GUARD_OPEN DUCKDB_EXTENSION_API bool DUCKDB_EXTENSION_GLUE( \ + 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); \ @@ -998,7 +1018,7 @@ typedef struct { #define DUCKDB_EXTENSION_ENTRYPOINT_CUSTOM \ DUCKDB_EXTENSION_GLOBAL static bool DUCKDB_EXTENSION_GLUE(DUCKDB_EXTENSION_NAME, _init_c_api_internal)( \ duckdb_extension_info info, struct duckdb_extension_access * access); \ - DUCKDB_EXTENSION_EXTERN_C_GUARD_OPEN DUCKDB_EXTENSION_API bool DUCKDB_EXTENSION_GLUE( \ + 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); \ return DUCKDB_EXTENSION_GLUE(DUCKDB_EXTENSION_NAME, _init_c_api_internal)(info, access); \ diff --git a/src/duckdb/src/main/capi/duckdb-c.cpp b/src/duckdb/src/main/capi/duckdb-c.cpp index ac944578c..ad47d7448 100644 --- a/src/duckdb/src/main/capi/duckdb-c.cpp +++ b/src/duckdb/src/main/capi/duckdb-c.cpp @@ -1,49 +1,88 @@ #include "duckdb/main/capi/capi_internal.hpp" using duckdb::Connection; -using duckdb::DatabaseData; +using duckdb::DatabaseWrapper; using duckdb::DBConfig; +using duckdb::DBInstanceCacheWrapper; using duckdb::DuckDB; using duckdb::ErrorData; -duckdb_state duckdb_open_ext(const char *path, duckdb_database *out, duckdb_config config, char **error) { - auto wrapper = new DatabaseData(); +duckdb_instance_cache duckdb_create_instance_cache() { + auto wrapper = new DBInstanceCacheWrapper(); + wrapper->instance_cache = duckdb::make_uniq(); + return reinterpret_cast(wrapper); +} + +void duckdb_destroy_instance_cache(duckdb_instance_cache *instance_cache) { + if (instance_cache && *instance_cache) { + auto wrapper = reinterpret_cast(*instance_cache); + delete wrapper; + *instance_cache = nullptr; + } +} + +duckdb_state duckdb_open_internal(DBInstanceCacheWrapper *cache, const char *path, duckdb_database *out, + duckdb_config config, char **out_error) { + auto wrapper = new DatabaseWrapper(); try { DBConfig default_config; default_config.SetOptionByName("duckdb_api", "capi"); DBConfig *db_config = &default_config; - DBConfig *user_config = (DBConfig *)config; + DBConfig *user_config = reinterpret_cast(config); if (user_config) { db_config = user_config; } - wrapper->database = duckdb::make_uniq(path, db_config); + if (cache) { + wrapper->database = cache->instance_cache->GetOrCreateInstance(path, *db_config, true); + } else { + wrapper->database = duckdb::make_shared_ptr(path, db_config); + } + } catch (std::exception &ex) { - if (error) { + if (out_error) { ErrorData parsed_error(ex); - *error = strdup(parsed_error.Message().c_str()); + *out_error = strdup(parsed_error.Message().c_str()); } delete wrapper; return DuckDBError; + } catch (...) { // LCOV_EXCL_START - if (error) { - *error = strdup("Unknown error"); + if (out_error) { + *out_error = strdup("Unknown error"); } delete wrapper; return DuckDBError; } // LCOV_EXCL_STOP - *out = (duckdb_database)wrapper; + + *out = reinterpret_cast(wrapper); return DuckDBSuccess; } +duckdb_state duckdb_get_or_create_from_cache(duckdb_instance_cache instance_cache, const char *path, + duckdb_database *out_database, duckdb_config config, char **out_error) { + if (!instance_cache) { + if (out_error) { + *out_error = strdup("instance cache cannot be nullptr"); + } + return DuckDBError; + } + auto cache = reinterpret_cast(instance_cache); + return duckdb_open_internal(cache, path, out_database, config, out_error); +} + +duckdb_state duckdb_open_ext(const char *path, duckdb_database *out, duckdb_config config, char **error) { + return duckdb_open_internal(nullptr, path, out, config, error); +} + duckdb_state duckdb_open(const char *path, duckdb_database *out) { return duckdb_open_ext(path, out, nullptr, nullptr); } void duckdb_close(duckdb_database *database) { if (database && *database) { - auto wrapper = reinterpret_cast(*database); + auto wrapper = reinterpret_cast(*database); delete wrapper; *database = nullptr; } @@ -53,14 +92,16 @@ duckdb_state duckdb_connect(duckdb_database database, duckdb_connection *out) { if (!database || !out) { return DuckDBError; } - auto wrapper = reinterpret_cast(database); + + auto wrapper = reinterpret_cast(database); Connection *connection; try { connection = new Connection(*wrapper->database); } catch (...) { // LCOV_EXCL_START return DuckDBError; } // LCOV_EXCL_STOP - *out = (duckdb_connection)connection; + + *out = reinterpret_cast(connection); return DuckDBSuccess; } diff --git a/src/duckdb/src/main/capi/replacement_scan-c.cpp b/src/duckdb/src/main/capi/replacement_scan-c.cpp index ff3eae4ff..5f23a3169 100644 --- a/src/duckdb/src/main/capi/replacement_scan-c.cpp +++ b/src/duckdb/src/main/capi/replacement_scan-c.cpp @@ -58,7 +58,7 @@ void duckdb_add_replacement_scan(duckdb_database db, duckdb_replacement_callback if (!db || !replacement) { return; } - auto wrapper = reinterpret_cast(db); + auto wrapper = reinterpret_cast(db); auto scan_info = duckdb::make_uniq(); scan_info->callback = replacement; scan_info->extra_data = extra_data; diff --git a/src/duckdb/src/main/capi/threading-c.cpp b/src/duckdb/src/main/capi/threading-c.cpp index b0a002f18..575f22c3c 100644 --- a/src/duckdb/src/main/capi/threading-c.cpp +++ b/src/duckdb/src/main/capi/threading-c.cpp @@ -1,10 +1,10 @@ #include "duckdb/main/capi/capi_internal.hpp" #include "duckdb/parallel/task_scheduler.hpp" -using duckdb::DatabaseData; +using duckdb::DatabaseWrapper; struct CAPITaskState { - CAPITaskState(duckdb::DatabaseInstance &db) + explicit CAPITaskState(duckdb::DatabaseInstance &db) : db(db), marker(duckdb::make_uniq>(true)), execute_count(0) { } @@ -17,7 +17,7 @@ void duckdb_execute_tasks(duckdb_database database, idx_t max_tasks) { if (!database) { return; } - auto wrapper = (DatabaseData *)database; + auto wrapper = reinterpret_cast(database); auto &scheduler = duckdb::TaskScheduler::GetScheduler(*wrapper->database->instance); scheduler.ExecuteTasks(max_tasks); } @@ -26,7 +26,7 @@ duckdb_task_state duckdb_create_task_state(duckdb_database database) { if (!database) { return nullptr; } - auto wrapper = (DatabaseData *)database; + auto wrapper = reinterpret_cast(database); auto state = new CAPITaskState(*wrapper->database->instance); return state; } diff --git a/src/duckdb/src/main/database.cpp b/src/duckdb/src/main/database.cpp index de60b1cf2..3bd387f84 100644 --- a/src/duckdb/src/main/database.cpp +++ b/src/duckdb/src/main/database.cpp @@ -26,6 +26,7 @@ #include "duckdb/storage/storage_manager.hpp" #include "duckdb/transaction/transaction_manager.hpp" #include "duckdb/main/capi/extension_api.hpp" +#include "duckdb/storage/compression/empty_validity.hpp" #ifndef DUCKDB_NO_THREADS #include "duckdb/common/thread.hpp" diff --git a/src/duckdb/src/main/extension/extension_load.cpp b/src/duckdb/src/main/extension/extension_load.cpp index a7a7c62fe..23101f722 100644 --- a/src/duckdb/src/main/extension/extension_load.cpp +++ b/src/duckdb/src/main/extension/extension_load.cpp @@ -48,7 +48,7 @@ struct DuckDBExtensionLoadState { //! This is the duckdb_database struct that will be passed to the extension during initialization. Note that the //! extension does not need to free it. - unique_ptr database_data; + unique_ptr database_data; //! The function pointer struct passed to the extension. The extension is expected to copy this struct during //! initialization @@ -88,8 +88,8 @@ struct ExtensionAccess { try { // Create the duckdb_database - load_state.database_data = make_uniq(); - load_state.database_data->database = make_uniq(load_state.db); + 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()); } catch (std::exception &ex) { load_state.error_data = ErrorData(ex); diff --git a/src/duckdb/src/parser/transform/expression/transform_function.cpp b/src/duckdb/src/parser/transform/expression/transform_function.cpp index ec8dad678..e410b7049 100644 --- a/src/duckdb/src/parser/transform/expression/transform_function.cpp +++ b/src/duckdb/src/parser/transform/expression/transform_function.cpp @@ -122,8 +122,8 @@ static bool IsOrderableWindowFunction(ExpressionType type) { case ExpressionType::WINDOW_CUME_DIST: case ExpressionType::WINDOW_LEAD: case ExpressionType::WINDOW_LAG: - return true; case ExpressionType::WINDOW_AGGREGATE: + return true; case ExpressionType::WINDOW_RANK_DENSE: return false; default: diff --git a/src/duckdb/src/planner/expression/bound_window_expression.cpp b/src/duckdb/src/planner/expression/bound_window_expression.cpp index 5f778db14..b189b8e6e 100644 --- a/src/duckdb/src/planner/expression/bound_window_expression.cpp +++ b/src/duckdb/src/planner/expression/bound_window_expression.cpp @@ -101,19 +101,23 @@ bool BoundWindowExpression::PartitionsAreEquivalent(const BoundWindowExpression return true; } -idx_t BoundWindowExpression::GetSharedOrders(const BoundWindowExpression &other) const { - const auto overlap = MinValue(orders.size(), other.orders.size()); +idx_t BoundWindowExpression::GetSharedOrders(const vector &lhs, const vector &rhs) { + const auto overlap = MinValue(lhs.size(), rhs.size()); idx_t result = 0; for (; result < overlap; ++result) { - if (!orders[result].Equals(other.orders[result])) { - return false; + if (!lhs.at(result).Equals(rhs.at(result))) { + return 0; } } return result; } +idx_t BoundWindowExpression::GetSharedOrders(const BoundWindowExpression &other) const { + return GetSharedOrders(orders, other.orders); +} + bool BoundWindowExpression::KeysAreCompatible(const BoundWindowExpression &other) const { if (!PartitionsAreEquivalent(other)) { return false; diff --git a/src/duckdb/src/planner/expression_binder/index_binder.cpp b/src/duckdb/src/planner/expression_binder/index_binder.cpp index 1d9d46bbc..950edb6e6 100644 --- a/src/duckdb/src/planner/expression_binder/index_binder.cpp +++ b/src/duckdb/src/planner/expression_binder/index_binder.cpp @@ -48,6 +48,23 @@ unique_ptr IndexBinder::BindIndex(const UnboundIndex &unbound_index) return index_type->create_instance(input); } +void IndexBinder::InitCreateIndexInfo(LogicalGet &get, CreateIndexInfo &info, const string &schema) { + auto &column_ids = get.GetColumnIds(); + for (auto &column_id : column_ids) { + if (column_id.IsRowIdColumn()) { + throw BinderException("cannot create an index on the rowid"); + } + auto col_id = column_id.GetPrimaryIndex(); + info.column_ids.push_back(col_id); + info.scan_types.push_back(get.returned_types[col_id]); + } + + info.scan_types.emplace_back(LogicalType::ROW_TYPE); + info.names = get.names; + info.schema = schema; + get.AddColumnId(COLUMN_IDENTIFIER_ROW_ID); +} + unique_ptr IndexBinder::BindCreateIndex(ClientContext &context, unique_ptr create_index_info, TableCatalogEntry &table_entry, @@ -70,23 +87,9 @@ unique_ptr IndexBinder::BindCreateIndex(ClientContext &context, } auto &get = plan->Cast(); - auto &column_ids = get.GetColumnIds(); - for (auto &column_id : column_ids) { - if (column_id.IsRowIdColumn()) { - throw BinderException("cannot create an index on the rowid"); - } - auto col_id = column_id.GetPrimaryIndex(); - create_index_info->column_ids.push_back(col_id); - create_index_info->scan_types.push_back(get.returned_types[col_id]); - } - - create_index_info->scan_types.emplace_back(LogicalType::ROW_TYPE); - create_index_info->names = get.names; - create_index_info->schema = table_entry.schema.name; - + InitCreateIndexInfo(get, *create_index_info, table_entry.schema.name); auto &bind_data = get.bind_data->Cast(); bind_data.is_create_index = true; - get.AddColumnId(COLUMN_IDENTIFIER_ROW_ID); auto result = make_uniq(std::move(create_index_info), std::move(expressions), table_entry, std::move(alter_table_info)); diff --git a/src/duckdb/src/storage/compression/dictionary/decompression.cpp b/src/duckdb/src/storage/compression/dictionary/decompression.cpp index a81c0e122..4063e9224 100644 --- a/src/duckdb/src/storage/compression/dictionary/decompression.cpp +++ b/src/duckdb/src/storage/compression/dictionary/decompression.cpp @@ -43,15 +43,18 @@ void CompressedStringScanState::Initialize(ColumnSegment &segment, bool initiali block_size = segment.GetBlockManager().GetBlockSize(); dict = DictionaryCompression::GetDictionary(segment, *handle); - dictionary = make_buffer(segment.type, index_buffer_count); - dictionary_size = index_buffer_count; if (!initialize_dictionary) { // Used by fetch, as fetch will never produce a DictionaryVector return; } + dictionary = make_buffer(segment.type, index_buffer_count); + dictionary_size = index_buffer_count; auto dict_child_data = FlatVector::GetData(*(dictionary)); + auto &validity = FlatVector::Validity(*dictionary); + D_ASSERT(index_buffer_count >= 1); + validity.SetInvalid(0); for (uint32_t i = 0; i < index_buffer_count; i++) { // NOTE: the passing of dict_child_vector, will not be used, its for big strings uint16_t str_len = GetStringLength(i); @@ -61,6 +64,7 @@ void CompressedStringScanState::Initialize(ColumnSegment &segment, bool initiali void CompressedStringScanState::ScanToFlatVector(Vector &result, idx_t result_offset, idx_t start, idx_t scan_count) { auto result_data = FlatVector::GetData(result); + auto &validity = FlatVector::Validity(result); // Handling non-bitpacking-group-aligned start values; idx_t start_offset = start % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE; @@ -82,6 +86,9 @@ void CompressedStringScanState::ScanToFlatVector(Vector &result, idx_t result_of for (idx_t i = 0; i < scan_count; i++) { // Lookup dict offset in index buffer auto string_number = sel_vec->get_index(i + start_offset); + if (string_number == 0) { + validity.SetInvalid(result_offset + i); + } auto dict_offset = index_buffer_ptr[string_number]; auto str_len = GetStringLength(UnsafeNumericCast(string_number)); result_data[result_offset + i] = FetchStringFromDict(UnsafeNumericCast(dict_offset), str_len); diff --git a/src/duckdb/src/storage/compression/dictionary_compression.cpp b/src/duckdb/src/storage/compression/dictionary_compression.cpp index 6f6b4beed..78915a374 100644 --- a/src/duckdb/src/storage/compression/dictionary_compression.cpp +++ b/src/duckdb/src/storage/compression/dictionary_compression.cpp @@ -157,7 +157,7 @@ void DictionaryCompressionStorage::StringFetchRow(ColumnSegment &segment, Column // Get Function //===--------------------------------------------------------------------===// CompressionFunction DictionaryCompressionFun::GetFunction(PhysicalType data_type) { - return CompressionFunction( + auto res = CompressionFunction( CompressionType::COMPRESSION_DICTIONARY, data_type, DictionaryCompressionStorage ::StringInitAnalyze, DictionaryCompressionStorage::StringAnalyze, DictionaryCompressionStorage::StringFinalAnalyze, DictionaryCompressionStorage::InitCompression, DictionaryCompressionStorage::Compress, @@ -165,6 +165,8 @@ CompressionFunction DictionaryCompressionFun::GetFunction(PhysicalType data_type DictionaryCompressionStorage::StringScan, DictionaryCompressionStorage::StringScanPartial, DictionaryCompressionStorage::StringFetchRow, UncompressedFunctions::EmptySkip, UncompressedStringStorage::StringInitSegment); + res.validity = CompressionValidity::NO_VALIDITY_REQUIRED; + return res; } bool DictionaryCompressionFun::TypeIsSupported(const PhysicalType physical_type) { diff --git a/src/duckdb/src/storage/compression/empty_validity.cpp b/src/duckdb/src/storage/compression/empty_validity.cpp new file mode 100644 index 000000000..0b6534153 --- /dev/null +++ b/src/duckdb/src/storage/compression/empty_validity.cpp @@ -0,0 +1,15 @@ +#include "duckdb/function/compression/compression.hpp" +#include "duckdb/storage/compression/empty_validity.hpp" + +namespace duckdb { + +CompressionFunction EmptyValidityCompressionFun::GetFunction(PhysicalType type) { + return EmptyValidityCompression::CreateFunction(); +} + +bool EmptyValidityCompressionFun::TypeIsSupported(const PhysicalType physical_type) { + D_ASSERT(physical_type == PhysicalType::BIT); + return true; +} + +} // namespace duckdb diff --git a/src/duckdb/src/storage/table/column_data.cpp b/src/duckdb/src/storage/table/column_data.cpp index 53e7c5459..985a59415 100644 --- a/src/duckdb/src/storage/table/column_data.cpp +++ b/src/duckdb/src/storage/table/column_data.cpp @@ -63,6 +63,16 @@ bool ColumnData::HasUpdates() const { return updates.get(); } +bool ColumnData::HasChanges(idx_t start_row, idx_t end_row) const { + if (!updates) { + return false; + } + if (updates->HasUpdates(start_row, end_row)) { + return true; + } + return false; +} + void ColumnData::ClearUpdates() { lock_guard update_guard(update_lock); updates.reset(); diff --git a/src/duckdb/src/storage/table/column_data_checkpointer.cpp b/src/duckdb/src/storage/table/column_data_checkpointer.cpp index 13658077d..ae92a6972 100644 --- a/src/duckdb/src/storage/table/column_data_checkpointer.cpp +++ b/src/duckdb/src/storage/table/column_data_checkpointer.cpp @@ -1,6 +1,7 @@ #include "duckdb/storage/table/column_data_checkpointer.hpp" #include "duckdb/main/config.hpp" #include "duckdb/storage/table/update_segment.hpp" +#include "duckdb/storage/compression/empty_validity.hpp" #include "duckdb/storage/data_table.hpp" #include "duckdb/parser/column_definition.hpp" #include "duckdb/storage/table/scan_state.hpp" @@ -273,11 +274,32 @@ void ColumnDataCheckpointer::DropSegments() { } } +bool ColumnDataCheckpointer::ValidityCoveredByBasedata(vector &result) { + if (result.size() != 2) { + return false; + } + if (!has_changes[0]) { + // The base data had no changes so it will not be rewritten + return false; + } + auto &base = result[0]; + D_ASSERT(base.function); + return base.function->validity == CompressionValidity::NO_VALIDITY_REQUIRED; +} + void ColumnDataCheckpointer::WriteToDisk() { DropSegments(); // Analyze the candidate functions to select one of them to use for compression auto analyze_result = DetectBestCompressionMethod(); + if (ValidityCoveredByBasedata(analyze_result)) { + D_ASSERT(analyze_result.size() == 2); + auto &validity = analyze_result[1]; + auto &config = DBConfig::GetConfig(db); + // Override the function to the COMPRESSION_EMPTY + // turning the compression+final compress steps into a no-op, saving a single empty segment + validity.function = config.GetCompressionFunction(CompressionType::COMPRESSION_EMPTY, PhysicalType::BIT); + } // Initialize the compression for the selected function D_ASSERT(analyze_result.size() == checkpoint_states.size()); @@ -328,13 +350,12 @@ bool ColumnDataCheckpointer::HasChanges(ColumnData &col_data) { if (segment->segment_type == ColumnSegmentType::TRANSIENT) { // transient segment: always need to write to disk return true; - } else { - // persistent segment; check if there were any updates or deletions in this segment - idx_t start_row_idx = segment->start - row_group.start; - idx_t end_row_idx = start_row_idx + segment->count; - if (col_data.updates && col_data.updates->HasUpdates(start_row_idx, end_row_idx)) { - return true; - } + } + // persistent segment; check if there were any updates or deletions in this segment + idx_t start_row_idx = segment->start - row_group.start; + idx_t end_row_idx = start_row_idx + segment->count; + if (col_data.HasChanges(start_row_idx, end_row_idx)) { + return true; } } return false; diff --git a/src/duckdb/third_party/httplib/httplib.hpp b/src/duckdb/third_party/httplib/httplib.hpp index c7da982b7..6432d5d1a 100644 --- a/src/duckdb/third_party/httplib/httplib.hpp +++ b/src/duckdb/third_party/httplib/httplib.hpp @@ -237,7 +237,6 @@ using socket_t = int; #include #include #include -#include #include #include #include @@ -246,9 +245,8 @@ using socket_t = int; #include #include #include -#include - #include "duckdb/common/re2_regex.hpp" +#include "duckdb/common/random_engine.hpp" #ifdef CPPHTTPLIB_OPENSSL_SUPPORT #ifdef _WIN32 @@ -4646,19 +4644,10 @@ inline std::string make_multipart_data_boundary() { static const char data[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; - // std::random_device might actually be deterministic on some - // platforms, but due to lack of support in the c++ standard library, - // doing better requires either some ugly hacks or breaking portability. - std::random_device seed_gen; - - // Request 128 bits of entropy for initialization - std::seed_seq seed_sequence{seed_gen(), seed_gen(), seed_gen(), seed_gen()}; - std::mt19937 engine(seed_sequence); - std::string result = "--cpp-httplib-multipart-data-"; - + duckdb::RandomEngine engine; for (auto i = 0; i < 16; i++) { - result += data[engine() % (sizeof(data) - 1)]; + result += data[engine.NextRandomInteger32(0,sizeof(data) - 1)]; } return result; diff --git a/src/duckdb/third_party/skiplist/SkipList.h b/src/duckdb/third_party/skiplist/SkipList.h index 5cf27c204..5b015acc3 100644 --- a/src/duckdb/third_party/skiplist/SkipList.h +++ b/src/duckdb/third_party/skiplist/SkipList.h @@ -446,7 +446,6 @@ #include #include // Used for HeadNode::_lacksIntegrityNodeReferencesNotInList() #include // Used for class Exception -#include #include "pcg_random.hpp" #ifdef DEBUG diff --git a/src/duckdb/ub_src_storage_compression.cpp b/src/duckdb/ub_src_storage_compression.cpp index 66e0303b5..491801cd7 100644 --- a/src/duckdb/ub_src_storage_compression.cpp +++ b/src/duckdb/ub_src_storage_compression.cpp @@ -24,3 +24,5 @@ #include "src/storage/compression/fsst.cpp" +#include "src/storage/compression/empty_validity.cpp" + From ad63b51e085c57a5fda50f8537f0023f281ee2aa Mon Sep 17 00:00:00 2001 From: DuckDB Labs GitHub Bot Date: Sat, 11 Jan 2025 00:34:12 +0000 Subject: [PATCH 09/16] Update vendored DuckDB sources to 5adc767b --- .../catalog_entry/type_catalog_entry.cpp | 4 +- .../src/catalog/default/default_functions.cpp | 3 + src/duckdb/src/common/extra_type_info.cpp | 68 +- src/duckdb/src/common/random_engine.cpp | 2 +- src/duckdb/src/common/types.cpp | 11 +- src/duckdb/src/execution/index/art/art.cpp | 2 + .../operator/join/physical_hash_join.cpp | 7 +- .../operator/scan/physical_table_scan.cpp | 30 +- src/duckdb/src/function/table/table_scan.cpp | 739 +++++++++++------- .../function/table/version/pragma_version.cpp | 6 +- .../catalog_entry/type_catalog_entry.hpp | 2 +- .../duckdb/common/extension_type_info.hpp | 24 +- .../duckdb/function/table/table_scan.hpp | 14 +- .../duckdb/function/table_function.hpp | 13 +- .../include/duckdb/main/extension_util.hpp | 2 +- .../include/duckdb/main/profiling_info.hpp | 4 +- .../include/duckdb/main/query_profiler.hpp | 5 +- .../parser/parsed_data/create_type_info.hpp | 10 +- .../duckdb/planner/filter/in_filter.hpp | 2 + .../src/main/extension/extension_util.cpp | 2 +- src/duckdb/src/main/query_profiler.cpp | 39 +- .../parser/parsed_data/create_type_info.cpp | 8 +- .../planner/binder/statement/bind_create.cpp | 48 +- src/duckdb/src/planner/filter/in_filter.cpp | 10 +- .../storage/serialization/serialize_types.cpp | 16 +- 25 files changed, 645 insertions(+), 426 deletions(-) diff --git a/src/duckdb/src/catalog/catalog_entry/type_catalog_entry.cpp b/src/duckdb/src/catalog/catalog_entry/type_catalog_entry.cpp index c60c7167d..be9c24834 100644 --- a/src/duckdb/src/catalog/catalog_entry/type_catalog_entry.cpp +++ b/src/duckdb/src/catalog/catalog_entry/type_catalog_entry.cpp @@ -11,7 +11,7 @@ namespace duckdb { TypeCatalogEntry::TypeCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateTypeInfo &info) : StandardEntry(CatalogType::TYPE_ENTRY, schema, catalog, info.name), user_type(info.type), - bind_modifiers(info.bind_modifiers) { + bind_function(info.bind_function) { this->temporary = info.temporary; this->internal = info.internal; this->dependencies = info.dependencies; @@ -35,7 +35,7 @@ unique_ptr TypeCatalogEntry::GetInfo() const { result->dependencies = dependencies; result->comment = comment; result->tags = tags; - result->bind_modifiers = bind_modifiers; + result->bind_function = bind_function; return std::move(result); } diff --git a/src/duckdb/src/catalog/default/default_functions.cpp b/src/duckdb/src/catalog/default/default_functions.cpp index ecffc34f7..7702bc4e0 100644 --- a/src/duckdb/src/catalog/default/default_functions.cpp +++ b/src/duckdb/src/catalog/default/default_functions.cpp @@ -110,6 +110,9 @@ static const DefaultMacro internal_macros[] = { {DEFAULT_SCHEMA, "geomean", {"x", nullptr}, {{nullptr, nullptr}}, "exp(avg(ln(x)))"}, {DEFAULT_SCHEMA, "geometric_mean", {"x", nullptr}, {{nullptr, nullptr}}, "geomean(x)"}, + {DEFAULT_SCHEMA, "weighted_avg", {"value", "weight", nullptr}, {{nullptr, nullptr}}, "SUM(value * weight) / SUM(CASE WHEN value IS NOT NULL THEN weight ELSE 0 END)"}, + {DEFAULT_SCHEMA, "wavg", {"value", "weight", nullptr}, {{nullptr, nullptr}}, "weighted_avg(value, weight)"}, + {DEFAULT_SCHEMA, "list_reverse", {"l", nullptr}, {{nullptr, nullptr}}, "l[:-:-1]"}, {DEFAULT_SCHEMA, "array_reverse", {"l", nullptr}, {{nullptr, nullptr}}, "list_reverse(l)"}, diff --git a/src/duckdb/src/common/extra_type_info.cpp b/src/duckdb/src/common/extra_type_info.cpp index a32129fd2..117f9b0f7 100644 --- a/src/duckdb/src/common/extra_type_info.cpp +++ b/src/duckdb/src/common/extra_type_info.cpp @@ -13,45 +13,64 @@ namespace duckdb { // Extension Type Info //===--------------------------------------------------------------------===// -static bool CompareModifiers(const vector &left, const vector &right) { - // Check if the common prefix of the properties is the same for both types - const auto common_props = MinValue(left.size(), right.size()); - for (idx_t i = 0; i < common_props; i++) { - if (left[i].type() != right[i].type()) { +bool ExtensionTypeInfo::Equals(optional_ptr lhs, optional_ptr rhs) { + // Either both are null, or both are the same, so they are equal + if (lhs.get() == rhs.get()) { + return true; + } + // If one is null, then we cant compare them + if (lhs == nullptr || rhs == nullptr) { + return true; + } + + // Both are not null, so we can compare them + D_ASSERT(lhs != nullptr && rhs != nullptr); + + // Compare modifiers + const auto &lhs_mods = lhs->modifiers; + const auto &rhs_mods = rhs->modifiers; + const auto common_mods = MinValue(lhs_mods.size(), rhs_mods.size()); + for (idx_t i = 0; i < common_mods; i++) { + // If the types are not strictly equal, they are not equal + auto &lhs_val = lhs_mods[i].value; + auto &rhs_val = rhs_mods[i].value; + + if (lhs_val.type() != rhs_val.type()) { return false; } - // Special case for nulls: - // For type modifiers, NULL is equivalent to ANY - if (left[i].IsNull() || right[i].IsNull()) { + + // If both are null, its fine + if (lhs_val.IsNull() && rhs_val.IsNull()) { continue; } - if (left[i] != right[i]) { + // If one is null, the other must be null too + if (lhs_val.IsNull() != rhs_val.IsNull()) { return false; } - } - return true; -} -bool ExtensionTypeInfo::Equals(optional_ptr other_p) const { - if (other_p == nullptr) { - return false; - } - if (!CompareModifiers(modifiers, other_p->modifiers)) { - return false; + if (lhs_val != rhs_val) { + return false; + } } // Properties are optional, so only compare those present in both - for (auto &kv : properties) { - auto it = other_p->properties.find(kv.first); - if (it == other_p->properties.end()) { + const auto &lhs_props = lhs->properties; + const auto &rhs_props = rhs->properties; + + for (const auto &kv : lhs_props) { + auto it = rhs_props.find(kv.first); + if (it == rhs_props.end()) { + // Continue continue; } if (kv.second != it->second) { + // Mismatch! return false; } } + // All ok! return true; } @@ -91,13 +110,16 @@ bool ExtraTypeInfo::Equals(ExtraTypeInfo *other_p) const { if (!alias.empty()) { return false; } + if (extension_info) { + return false; + } //! We only need to compare aliases when both types have them in this case return true; } if (alias != other_p->alias) { return false; } - if (extension_info && !extension_info->Equals(other_p->extension_info.get())) { + if (!ExtensionTypeInfo::Equals(extension_info, other_p->extension_info)) { return false; } return true; @@ -111,7 +133,7 @@ bool ExtraTypeInfo::Equals(ExtraTypeInfo *other_p) const { if (alias != other_p->alias) { return false; } - if (extension_info && !extension_info->Equals(other_p->extension_info.get())) { + if (!ExtensionTypeInfo::Equals(extension_info, other_p->extension_info)) { return false; } return EqualsInternal(other_p); diff --git a/src/duckdb/src/common/random_engine.cpp b/src/duckdb/src/common/random_engine.cpp index 23eb253e3..cf558ea7a 100644 --- a/src/duckdb/src/common/random_engine.cpp +++ b/src/duckdb/src/common/random_engine.cpp @@ -20,7 +20,7 @@ struct RandomState { RandomEngine::RandomEngine(int64_t seed) : random_state(make_uniq()) { if (seed < 0) { #ifdef __linux__ - idx_t random_seed; + idx_t random_seed = 0; auto result = syscall(SYS_getrandom, &random_seed, sizeof(random_seed), 0); if (result == -1) { // Something went wrong with the syscall, we use chrono diff --git a/src/duckdb/src/common/types.cpp b/src/duckdb/src/common/types.cpp index 4beade0ef..342a84bc0 100644 --- a/src/duckdb/src/common/types.cpp +++ b/src/duckdb/src/common/types.cpp @@ -365,7 +365,7 @@ bool TypeIsInteger(PhysicalType type) { type == PhysicalType::UINT128; } -static string TypeModifierListToString(const vector &mod_list) { +static string TypeModifierListToString(const vector &mod_list) { string result; if (mod_list.empty()) { return result; @@ -499,7 +499,14 @@ string LogicalType::ToString() const { result += KeywordHelper::WriteOptionallyQuoted(type); if (!mods.empty()) { - result += TypeModifierListToString(mods); + result += "("; + for (idx_t i = 0; i < mods.size(); i++) { + result += mods[i].ToString(); + if (i < mods.size() - 1) { + result += ", "; + } + } + result += ")"; } return result; diff --git a/src/duckdb/src/execution/index/art/art.cpp b/src/duckdb/src/execution/index/art/art.cpp index 1a3cada73..a92f2eebf 100644 --- a/src/duckdb/src/execution/index/art/art.cpp +++ b/src/duckdb/src/execution/index/art/art.cpp @@ -138,8 +138,10 @@ unique_ptr ART::TryInitializeScan(const Expression &expr, const // Try to find a matching index for any of the filter expressions. ComparisonExpressionMatcher matcher; + // Match on a comparison type. matcher.expr_type = make_uniq(); + // Match on a constant comparison with the indexed expression. matcher.matchers.push_back(make_uniq(expr)); matcher.matchers.push_back(make_uniq()); 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 dcff82f0d..3c01a4acf 100644 --- a/src/duckdb/src/execution/operator/join/physical_hash_join.cpp +++ b/src/duckdb/src/execution/operator/join/physical_hash_join.cpp @@ -637,11 +637,14 @@ void JoinFilterPushdownInfo::PushInFilter(const JoinFilterPushdownFilter &info, } // generate the OR filter - auto or_filter = make_uniq(std::move(in_list)); + auto in_filter = make_uniq(std::move(in_list)); + in_filter->origin_is_hash_join = true; + // we push the OR filter as an OptionalFilter so that we can use it for zonemap pruning only // the IN-list is expensive to execute otherwise - auto filter = make_uniq(std::move(or_filter)); + auto filter = make_uniq(std::move(in_filter)); info.dynamic_filters->PushFilter(op, filter_col_idx, std::move(filter)); + return; } unique_ptr JoinFilterPushdownInfo::Finalize(ClientContext &context, JoinHashTable &ht, 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 91f509a39..0ea996d34 100644 --- a/src/duckdb/src/execution/operator/scan/physical_table_scan.cpp +++ b/src/duckdb/src/execution/operator/scan/physical_table_scan.cpp @@ -27,9 +27,12 @@ class TableScanGlobalSourceState : public GlobalSourceState { if (op.dynamic_filters && op.dynamic_filters->HasFilters()) { table_filters = op.dynamic_filters->GetFinalTableFilters(op, op.table_filters.get()); } + if (op.function.init_global) { - TableFunctionInitInput input(op.bind_data.get(), op.column_ids, op.projection_ids, GetTableFilters(op), + auto filters = table_filters ? *table_filters : GetTableFilters(op); + TableFunctionInitInput input(op.bind_data.get(), op.column_ids, op.projection_ids, filters, op.extra_info.sample_options); + global_state = op.function.init_global(context, input); if (global_state) { max_threads = global_state->MaxThreads(); @@ -92,23 +95,24 @@ unique_ptr PhysicalTableScan::GetGlobalSourceState(ClientCont SourceResultType PhysicalTableScan::GetData(ExecutionContext &context, DataChunk &chunk, OperatorSourceInput &input) const { D_ASSERT(!column_ids.empty()); - auto &gstate = input.global_state.Cast(); - auto &state = input.local_state.Cast(); + auto &g_state = input.global_state.Cast(); + auto &l_state = input.local_state.Cast(); + + TableFunctionInput data(bind_data.get(), l_state.local_state.get(), g_state.global_state.get()); - TableFunctionInput data(bind_data.get(), state.local_state.get(), gstate.global_state.get()); if (function.function) { function.function(context.client, data, chunk); - } else { - if (gstate.in_out_final) { - function.in_out_function_final(context, data, chunk); - } - function.in_out_function(context, data, gstate.input_chunk, chunk); - if (chunk.size() == 0 && function.in_out_function_final) { - function.in_out_function_final(context, data, chunk); - gstate.in_out_final = true; - } + return chunk.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT; } + if (g_state.in_out_final) { + function.in_out_function_final(context, data, chunk); + } + function.in_out_function(context, data, g_state.input_chunk, chunk); + if (chunk.size() == 0 && function.in_out_function_final) { + function.in_out_function_final(context, data, chunk); + g_state.in_out_final = true; + } return chunk.size() == 0 ? SourceResultType::FINISHED : SourceResultType::HAVE_MORE_OUTPUT; } diff --git a/src/duckdb/src/function/table/table_scan.cpp b/src/duckdb/src/function/table/table_scan.cpp index 30f809a87..b36abbb9b 100644 --- a/src/duckdb/src/function/table/table_scan.cpp +++ b/src/duckdb/src/function/table/table_scan.cpp @@ -19,19 +19,28 @@ #include "duckdb/transaction/local_storage.hpp" #include "duckdb/storage/storage_index.hpp" #include "duckdb/main/client_data.hpp" +#include "duckdb/common/algorithm.hpp" +#include "duckdb/planner/filter/optional_filter.hpp" +#include "duckdb/planner/filter/in_filter.hpp" +#include "duckdb/planner/expression/bound_constant_expression.hpp" +#include "duckdb/planner/expression/bound_comparison_expression.hpp" +#include "duckdb/planner/filter/conjunction_filter.hpp" namespace duckdb { -//===--------------------------------------------------------------------===// -// Table Scan -//===--------------------------------------------------------------------===// -bool TableScanParallelStateNext(ClientContext &context, const FunctionData *bind_data_p, - LocalTableFunctionState *local_state, GlobalTableFunctionState *gstate); - struct TableScanLocalState : public LocalTableFunctionState { - //! The current position in the scan + //! The current position in the scan. TableScanState scan_state; - //! The DataChunk containing all read columns (even filter columns that are immediately removed) + //! The DataChunk containing all read columns. + //! This includes filter columns, which are immediately removed. + DataChunk all_columns; +}; + +struct IndexScanLocalState : public LocalTableFunctionState { + //! The batch index, which determines the offset in the row ID vector. + idx_t batch_index; + //! The DataChunk containing all read columns. + //! This includes filter columns, which are immediately removed. DataChunk all_columns; }; @@ -47,356 +56,530 @@ static StorageIndex GetStorageIndex(TableCatalogEntry &table, const ColumnIndex if (column_id.IsRowIdColumn()) { return StorageIndex(); } - // the index of the base ColumnIndex is equal to the physical column index in the table - // for any child indices - the indices are already the physical indices - // (since only the top-level can have generated columns) + + // The index of the base ColumnIndex is equal to the physical column index in the table + // for any child indices because the indices are already the physical indices. + // Only the top-level can have generated columns. auto &col = table.GetColumn(column_id.ToLogical()); auto result = TransformStorageIndex(column_id); result.SetIndex(col.StorageOid()); return result; } -struct TableScanGlobalState : public GlobalTableFunctionState { +class TableScanGlobalState : public GlobalTableFunctionState { +public: TableScanGlobalState(ClientContext &context, const FunctionData *bind_data_p) { D_ASSERT(bind_data_p); auto &bind_data = bind_data_p->Cast(); max_threads = bind_data.table.GetStorage().MaxThreads(context); } - ParallelTableScanState state; + //! The maximum number of threads for this table scan. idx_t max_threads; - + //! The projected columns of this table scan. vector projection_ids; + //! The types of all scanned columns. vector scanned_types; +public: + virtual unique_ptr InitLocalState(ExecutionContext &context, + TableFunctionInitInput &input) = 0; + virtual void TableScanFunc(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) = 0; + virtual double TableScanProgress(ClientContext &context, const FunctionData *bind_data_p) const = 0; + virtual OperatorPartitionData TableScanGetPartitionData(ClientContext &context, + TableFunctionGetPartitionInput &input) = 0; + idx_t MaxThreads() const override { return max_threads; } - bool CanRemoveFilterColumns() const { return !projection_ids.empty(); } }; -static unique_ptr TableScanInitLocal(ExecutionContext &context, TableFunctionInitInput &input, - GlobalTableFunctionState *gstate) { - auto result = make_uniq(); - auto &bind_data = input.bind_data->Cast(); - vector storage_ids; - for (auto &col : input.column_indexes) { - storage_ids.push_back(GetStorageIndex(bind_data.table, col)); +class DuckIndexScanState : public TableScanGlobalState { +public: + DuckIndexScanState(ClientContext &context, const FunctionData *bind_data_p) + : TableScanGlobalState(context, bind_data_p), next_batch_index(0), finished(false) { } - result->scan_state.Initialize(std::move(storage_ids), input.filters.get(), input.sample_options.get()); - TableScanParallelStateNext(context.client, input.bind_data.get(), result.get(), gstate); - if (input.CanRemoveFilterColumns()) { - auto &tsgs = gstate->Cast(); - result->all_columns.Initialize(context.client, tsgs.scanned_types); + + //! The batch index of the next Sink. + //! Also determines the offset of the next chunk. I.e., offset = next_batch_index * STANDARD_VECTOR_SIZE. + idx_t next_batch_index; + //! The total scanned row IDs. + unsafe_vector row_ids; + //! The column IDs of the to-be-scanned columns. + vector column_ids; + //! True, if no more row IDs must be scanned. + bool finished; + //! Synchronize changes to the global index scan state. + mutex index_scan_lock; + + ColumnFetchState fetch_state; + TableScanState table_scan_state; + +public: + unique_ptr InitLocalState(ExecutionContext &context, + TableFunctionInitInput &input) override { + auto l_state = make_uniq(); + if (input.CanRemoveFilterColumns()) { + l_state->all_columns.Initialize(context.client, scanned_types); + } + return std::move(l_state); } - result->scan_state.options.force_fetch_row = ClientConfig::GetConfig(context.client).force_fetch_row; + void TableScanFunc(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) override { + auto &bind_data = data_p.bind_data->Cast(); + auto &tx = DuckTransaction::Get(context, bind_data.table.catalog); + auto &storage = bind_data.table.GetStorage(); + auto &l_state = data_p.local_state->Cast(); + + auto row_id_count = row_ids.size(); + idx_t scan_count = 0; + idx_t offset = 0; + + { + // Synchronize changes to the shared global state. + lock_guard l(index_scan_lock); + if (!finished) { + l_state.batch_index = next_batch_index; + next_batch_index++; + + offset = l_state.batch_index * STANDARD_VECTOR_SIZE; + auto remaining = row_id_count - offset; + scan_count = remaining < STANDARD_VECTOR_SIZE ? remaining : STANDARD_VECTOR_SIZE; + finished = remaining < STANDARD_VECTOR_SIZE ? true : false; + } + } - return std::move(result); -} + if (scan_count != 0) { + auto row_id_data = (data_ptr_t)&row_ids[0 + offset]; // NOLINT - this is not pretty + Vector local_vector(LogicalType::ROW_TYPE, row_id_data); -unique_ptr TableScanInitGlobal(ClientContext &context, TableFunctionInitInput &input) { - D_ASSERT(input.bind_data); - auto &bind_data = input.bind_data->Cast(); - auto result = make_uniq(context, input.bind_data.get()); - bind_data.table.GetStorage().InitializeParallelScan(context, result->state); - if (input.CanRemoveFilterColumns()) { - result->projection_ids = input.projection_ids; - const auto &columns = bind_data.table.GetColumns(); - for (const auto &col_idx : input.column_indexes) { - if (col_idx.IsRowIdColumn()) { - result->scanned_types.emplace_back(LogicalType::ROW_TYPE); + if (CanRemoveFilterColumns()) { + l_state.all_columns.Reset(); + storage.Fetch(tx, l_state.all_columns, column_ids, local_vector, scan_count, fetch_state); + output.ReferenceColumns(l_state.all_columns, projection_ids); } else { - result->scanned_types.push_back(columns.GetColumn(col_idx.ToLogical()).Type()); + storage.Fetch(tx, output, column_ids, local_vector, scan_count, fetch_state); + } + } + + if (output.size() == 0) { + auto &local_storage = LocalStorage::Get(tx); + if (CanRemoveFilterColumns()) { + l_state.all_columns.Reset(); + local_storage.Scan(table_scan_state.local_state, column_ids, l_state.all_columns); + output.ReferenceColumns(l_state.all_columns, projection_ids); + } else { + local_storage.Scan(table_scan_state.local_state, column_ids, output); } } } - return std::move(result); -} -static unique_ptr TableScanStatistics(ClientContext &context, const FunctionData *bind_data_p, - column_t column_id) { - auto &bind_data = bind_data_p->Cast(); - auto &local_storage = LocalStorage::Get(context, bind_data.table.catalog); - if (local_storage.Find(bind_data.table.GetStorage())) { - // we don't emit any statistics for tables that have outstanding transaction-local data - return nullptr; + double TableScanProgress(ClientContext &context, const FunctionData *bind_data_p) const override { + auto total_rows = row_ids.size(); + if (total_rows == 0) { + return 100; + } + + auto scanned_rows = next_batch_index * STANDARD_VECTOR_SIZE; + auto percentage = 100 * (static_cast(scanned_rows) / static_cast(total_rows)); + return percentage > 100 ? 100 : percentage; } - return bind_data.table.GetStatistics(context, column_id); -} -static void TableScanFunc(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) { - auto &bind_data = data_p.bind_data->Cast(); - auto &gstate = data_p.global_state->Cast(); - auto &state = data_p.local_state->Cast(); - auto &transaction = DuckTransaction::Get(context, bind_data.table.catalog); - auto &storage = bind_data.table.GetStorage(); + OperatorPartitionData TableScanGetPartitionData(ClientContext &context, + TableFunctionGetPartitionInput &input) override { + auto &l_state = input.local_state->Cast(); + return OperatorPartitionData(l_state.batch_index); + } +}; - state.scan_state.options.force_fetch_row = ClientConfig::GetConfig(context).force_fetch_row; - do { - if (bind_data.is_create_index) { - storage.CreateIndexScan(state.scan_state, output, - TableScanType::TABLE_SCAN_COMMITTED_ROWS_OMIT_PERMANENTLY_DELETED); - } else if (gstate.CanRemoveFilterColumns()) { - state.all_columns.Reset(); - storage.Scan(transaction, state.all_columns, state.scan_state); - output.ReferenceColumns(state.all_columns, gstate.projection_ids); - } else { - storage.Scan(transaction, output, state.scan_state); - } - if (output.size() > 0) { - return; - } - if (!TableScanParallelStateNext(context, data_p.bind_data.get(), data_p.local_state.get(), - data_p.global_state.get())) { - return; +class DuckTableScanState : public TableScanGlobalState { +public: + DuckTableScanState(ClientContext &context, const FunctionData *bind_data_p) + : TableScanGlobalState(context, bind_data_p) { + } + + ParallelTableScanState state; + +public: + unique_ptr InitLocalState(ExecutionContext &context, + TableFunctionInitInput &input) override { + auto &bind_data = input.bind_data->Cast(); + auto l_state = make_uniq(); + + vector storage_ids; + for (auto &col : input.column_indexes) { + storage_ids.push_back(GetStorageIndex(bind_data.table, col)); } - } while (true); -} -bool TableScanParallelStateNext(ClientContext &context, const FunctionData *bind_data_p, - LocalTableFunctionState *local_state, GlobalTableFunctionState *global_state) { - auto &bind_data = bind_data_p->Cast(); - auto ¶llel_state = global_state->Cast(); - auto &state = local_state->Cast(); - auto &storage = bind_data.table.GetStorage(); + l_state->scan_state.Initialize(std::move(storage_ids), input.filters.get(), input.sample_options.get()); - return storage.NextParallelScan(context, parallel_state.state, state.scan_state); -} + auto &storage = bind_data.table.GetStorage(); + storage.NextParallelScan(context.client, state, l_state->scan_state); + if (input.CanRemoveFilterColumns()) { + l_state->all_columns.Initialize(context.client, scanned_types); + } -double TableScanProgress(ClientContext &context, const FunctionData *bind_data_p, - const GlobalTableFunctionState *gstate_p) { - auto &bind_data = bind_data_p->Cast(); - auto &gstate = gstate_p->Cast(); - auto &storage = bind_data.table.GetStorage(); - idx_t total_rows = storage.GetTotalRows(); - if (total_rows == 0) { - //! Table is either empty or smaller than a vector size, so it is finished - return 100; - } - idx_t scanned_rows = gstate.state.scan_state.processed_rows; - scanned_rows += gstate.state.local_state.processed_rows; - auto percentage = 100 * (static_cast(scanned_rows) / static_cast(total_rows)); - if (percentage > 100) { - //! In case the last chunk has less elements than STANDARD_VECTOR_SIZE, if our percentage is over 100 - //! It means we finished this table. - return 100; - } - return percentage; -} + l_state->scan_state.options.force_fetch_row = ClientConfig::GetConfig(context.client).force_fetch_row; + return std::move(l_state); + } -OperatorPartitionData TableScanGetPartitionData(ClientContext &context, TableFunctionGetPartitionInput &input) { - if (input.partition_info.RequiresPartitionColumns()) { - throw InternalException("TableScan::GetPartitionData: partition columns not supported"); + void TableScanFunc(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) override { + auto &bind_data = data_p.bind_data->Cast(); + auto &tx = DuckTransaction::Get(context, bind_data.table.catalog); + auto &storage = bind_data.table.GetStorage(); + + auto &l_state = data_p.local_state->Cast(); + l_state.scan_state.options.force_fetch_row = ClientConfig::GetConfig(context).force_fetch_row; + + do { + if (bind_data.is_create_index) { + storage.CreateIndexScan(l_state.scan_state, output, + TableScanType::TABLE_SCAN_COMMITTED_ROWS_OMIT_PERMANENTLY_DELETED); + } else if (CanRemoveFilterColumns()) { + l_state.all_columns.Reset(); + storage.Scan(tx, l_state.all_columns, l_state.scan_state); + output.ReferenceColumns(l_state.all_columns, projection_ids); + } else { + storage.Scan(tx, output, l_state.scan_state); + } + if (output.size() > 0) { + return; + } + + auto next = storage.NextParallelScan(context, state, l_state.scan_state); + if (!next) { + return; + } + } while (true); } - auto &state = input.local_state->Cast(); - if (state.scan_state.table_state.row_group) { - return OperatorPartitionData(state.scan_state.table_state.batch_index); + + double TableScanProgress(ClientContext &context, const FunctionData *bind_data_p) const override { + auto &bind_data = bind_data_p->Cast(); + auto &storage = bind_data.table.GetStorage(); + auto total_rows = storage.GetTotalRows(); + + // The table is empty or smaller than the standard vector size. + if (total_rows == 0) { + return 100; + } + + idx_t scanned_rows = state.scan_state.processed_rows; + scanned_rows += state.local_state.processed_rows; + auto percentage = 100 * (static_cast(scanned_rows) / static_cast(total_rows)); + if (percentage > 100) { + // If the last chunk has fewer elements than STANDARD_VECTOR_SIZE, and if our percentage is over 100, + // then we finished this table. + return 100; + } + return percentage; } - if (state.scan_state.local_state.row_group) { - return OperatorPartitionData(state.scan_state.table_state.batch_index + - state.scan_state.local_state.batch_index); + + OperatorPartitionData TableScanGetPartitionData(ClientContext &context, + TableFunctionGetPartitionInput &input) override { + auto &l_state = input.local_state->Cast(); + if (l_state.scan_state.table_state.row_group) { + return OperatorPartitionData(l_state.scan_state.table_state.batch_index); + } + if (l_state.scan_state.local_state.row_group) { + return OperatorPartitionData(l_state.scan_state.table_state.batch_index + + l_state.scan_state.local_state.batch_index); + } + return OperatorPartitionData(0); } - return OperatorPartitionData(0); -} +}; -vector TableScanGetPartitionStats(ClientContext &context, GetPartitionStatsInput &input) { - auto &bind_data = input.bind_data->Cast(); - vector result; - auto &storage = bind_data.table.GetStorage(); - return storage.GetPartitionStats(context); +static unique_ptr TableScanInitLocal(ExecutionContext &context, TableFunctionInitInput &input, + GlobalTableFunctionState *g_state) { + auto &cast_g_state = g_state->Cast(); + return cast_g_state.InitLocalState(context, input); } -BindInfo TableScanGetBindInfo(const optional_ptr bind_data_p) { - auto &bind_data = bind_data_p->Cast(); - return BindInfo(bind_data.table); -} +unique_ptr DuckTableScanInitGlobal(ClientContext &context, TableFunctionInitInput &input, + DataTable &storage, const TableScanBindData &bind_data) { + auto g_state = make_uniq(context, input.bind_data.get()); + storage.InitializeParallelScan(context, g_state->state); + if (!input.CanRemoveFilterColumns()) { + return std::move(g_state); + } -void TableScanDependency(LogicalDependencyList &entries, const FunctionData *bind_data_p) { - auto &bind_data = bind_data_p->Cast(); - entries.AddDependency(bind_data.table); + g_state->projection_ids = input.projection_ids; + const auto &columns = bind_data.table.GetColumns(); + for (const auto &col_idx : input.column_indexes) { + if (col_idx.IsRowIdColumn()) { + g_state->scanned_types.emplace_back(LogicalType::ROW_TYPE); + } else { + g_state->scanned_types.push_back(columns.GetColumn(col_idx.ToLogical()).Type()); + } + } + return std::move(g_state); } -unique_ptr TableScanCardinality(ClientContext &context, const FunctionData *bind_data_p) { - auto &bind_data = bind_data_p->Cast(); +unique_ptr DuckIndexScanInitGlobal(ClientContext &context, TableFunctionInitInput &input, + DataTable &storage, const TableScanBindData &bind_data, + unsafe_vector &row_ids) { + auto g_state = make_uniq(context, input.bind_data.get()); + if (!row_ids.empty()) { + std::sort(row_ids.begin(), row_ids.end()); + g_state->row_ids = std::move(row_ids); + } + g_state->finished = g_state->row_ids.empty() ? true : false; + auto &local_storage = LocalStorage::Get(context, bind_data.table.catalog); - auto &storage = bind_data.table.GetStorage(); - idx_t table_rows = storage.GetTotalRows(); - idx_t estimated_cardinality = table_rows + local_storage.AddedRows(bind_data.table.GetStorage()); - return make_uniq(table_rows, estimated_cardinality); -} + g_state->table_scan_state.options.force_fetch_row = ClientConfig::GetConfig(context).force_fetch_row; -//===--------------------------------------------------------------------===// -// Index Scan -//===--------------------------------------------------------------------===// -struct IndexScanGlobalState : public GlobalTableFunctionState { - IndexScanGlobalState(const data_ptr_t row_id_data, const idx_t count) - : row_ids(LogicalType::ROW_TYPE, row_id_data), row_ids_count(count), row_ids_offset(0) { + if (input.CanRemoveFilterColumns()) { + g_state->projection_ids = input.projection_ids; } - const Vector row_ids; - const idx_t row_ids_count; - idx_t row_ids_offset; - ColumnFetchState fetch_state; - TableScanState local_storage_state; - vector column_ids; - bool finished; -}; + const auto &columns = bind_data.table.GetColumns(); + for (const auto &col_idx : input.column_indexes) { + g_state->column_ids.push_back(GetStorageIndex(bind_data.table, col_idx)); + if (col_idx.IsRowIdColumn()) { + g_state->scanned_types.emplace_back(LogicalType::ROW_TYPE); + continue; + } + g_state->scanned_types.push_back(columns.GetColumn(col_idx.ToLogical()).Type()); + } -static unique_ptr IndexScanInitGlobal(ClientContext &context, TableFunctionInitInput &input) { - auto &bind_data = input.bind_data->Cast(); + g_state->table_scan_state.Initialize(g_state->column_ids, input.filters.get()); + local_storage.InitializeScan(storage, g_state->table_scan_state.local_state, input.filters); + + // Const-cast to indicate an index scan. + // We need this information in the bind data so that we can access it during ANALYZE. + auto &no_const_bind_data = bind_data.CastNoConst(); + no_const_bind_data.is_index_scan = true; + + return std::move(g_state); +} - data_ptr_t row_id_data = nullptr; - if (!bind_data.row_ids.empty()) { - row_id_data = (data_ptr_t)&bind_data.row_ids[0]; // NOLINT - this is not pretty +void ExtractInFilter(unique_ptr &filter, BoundColumnRefExpression &bound_ref, + unique_ptr>> &filter_expressions) { + // Special-handling of IN filters. + // They are part of a CONJUNCTION_AND. + if (filter->filter_type != TableFilterType::CONJUNCTION_AND) { + return; } - auto result = make_uniq(row_id_data, bind_data.row_ids.size()); - auto &local_storage = LocalStorage::Get(context, bind_data.table.catalog); + auto &and_filter = filter->Cast(); + auto &children = and_filter.child_filters; + if (children.empty()) { + return; + } + if (children[0]->filter_type != TableFilterType::OPTIONAL_FILTER) { + return; + } - result->local_storage_state.options.force_fetch_row = ClientConfig::GetConfig(context).force_fetch_row; - result->column_ids.reserve(input.column_ids.size()); - for (auto &col_id : input.column_indexes) { - result->column_ids.push_back(GetStorageIndex(bind_data.table, col_id)); + auto &optional_filter = children[0]->Cast(); + auto &child = optional_filter.child_filter; + if (child->filter_type != TableFilterType::IN_FILTER) { + return; } - result->local_storage_state.Initialize(result->column_ids, input.filters.get()); - local_storage.InitializeScan(bind_data.table.GetStorage(), result->local_storage_state.local_state, input.filters); + auto &in_filter = child->Cast(); + if (!in_filter.origin_is_hash_join) { + return; + } - result->finished = false; - return std::move(result); + // They are all on the same column, so we can split them. + for (const auto &value : in_filter.values) { + auto bound_constant = make_uniq(value); + auto filter_expr = make_uniq(ExpressionType::COMPARE_EQUAL, bound_ref.Copy(), + std::move(bound_constant)); + filter_expressions->push_back(std::move(filter_expr)); + } } -static void IndexScanFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) { - auto &bind_data = data_p.bind_data->Cast(); - auto &state = data_p.global_state->Cast(); - auto &transaction = DuckTransaction::Get(context, bind_data.table.catalog); - auto &local_storage = LocalStorage::Get(transaction); +unique_ptr>> ExtractFilters(const ColumnDefinition &col, unique_ptr &filter, + idx_t storage_idx) { + ColumnBinding binding(0, storage_idx); + auto bound_ref = make_uniq(col.Name(), col.Type(), binding); + + auto filter_expressions = make_uniq>>(); + ExtractInFilter(filter, *bound_ref, filter_expressions); - if (!state.finished) { - auto remaining = state.row_ids_count - state.row_ids_offset; - auto scan_count = remaining < STANDARD_VECTOR_SIZE ? remaining : STANDARD_VECTOR_SIZE; + if (filter_expressions->empty()) { + auto filter_expr = filter->ToExpression(*bound_ref); + filter_expressions->push_back(std::move(filter_expr)); + } + return filter_expressions; +} - Vector row_ids(state.row_ids, state.row_ids_offset, state.row_ids_offset + scan_count); - bind_data.table.GetStorage().Fetch(transaction, output, state.column_ids, row_ids, scan_count, - state.fetch_state); +bool TryScanIndex(ART &art, const ColumnList &column_list, TableFunctionInitInput &input, TableFilterSet &filter_set, + idx_t max_count, unsafe_vector &row_ids) { + // FIXME: No support for index scans on compound ARTs. + // See note above on multi-filter support. + if (art.unbound_expressions.size() > 1) { + return false; + } - state.row_ids_offset += scan_count; - if (state.row_ids_offset == state.row_ids_count) { - state.finished = true; + auto index_expr = art.unbound_expressions[0]->Copy(); + auto &indexed_columns = art.GetColumnIds(); + + // NOTE: We do not push down multi-column filters, e.g., 42 = a + b. + if (indexed_columns.size() != 1) { + return false; + } + + // Get ART column. + auto &col = column_list.GetColumn(LogicalIndex(indexed_columns[0])); + + // The indexes of the filters match input.column_indexes, which are: i -> column_index. + // Try to find a filter on the ART column. + optional_idx storage_index; + for (idx_t i = 0; i < input.column_indexes.size(); i++) { + if (input.column_indexes[i].ToLogical() == col.Logical()) { + storage_index = i; + break; } } - if (output.size() == 0) { - local_storage.Scan(state.local_storage_state.local_state, state.column_ids, output); + + // No filter matches the ART column. + if (!storage_index.IsValid()) { + return false; } -} -static void RewriteIndexExpression(Index &index, LogicalGet &get, Expression &expr, bool &rewrite_possible) { - if (expr.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) { - auto &bound_colref = expr.Cast(); - // bound column ref: rewrite to fit in the current set of bound column ids - bound_colref.binding.table_index = get.table_index; - auto &column_ids = index.GetColumnIds(); - auto &get_column_ids = get.GetColumnIds(); - column_t referenced_column = column_ids[bound_colref.binding.column_index]; - // search for the referenced column in the set of column_ids - for (idx_t i = 0; i < get_column_ids.size(); i++) { - auto column_id = get_column_ids[i].GetPrimaryIndex(); - if (column_id == referenced_column) { - bound_colref.binding.column_index = i; - return; - } + // Try to find a matching filter for the column. + auto filter = filter_set.filters.find(storage_index.GetIndex()); + if (filter == filter_set.filters.end()) { + return false; + } + + auto filter_expressions = ExtractFilters(col, filter->second, storage_index.GetIndex()); + for (const auto &filter_expr : *filter_expressions) { + auto scan_state = art.TryInitializeScan(*index_expr, *filter_expr); + if (!scan_state) { + return false; + } + + // Check if we can use an index scan, and already retrieve the matching row ids. + if (!art.Scan(*scan_state, max_count, row_ids)) { + row_ids.clear(); + return false; } - // column id not found in bound columns in the LogicalGet: rewrite not possible - rewrite_possible = false; } - ExpressionIterator::EnumerateChildren( - expr, [&](Expression &child) { RewriteIndexExpression(index, get, child, rewrite_possible); }); + return true; } -void TableScanPushdownComplexFilter(ClientContext &context, LogicalGet &get, FunctionData *bind_data_p, - vector> &filters) { - auto &bind_data = bind_data_p->Cast(); +unique_ptr TableScanInitGlobal(ClientContext &context, TableFunctionInitInput &input) { + D_ASSERT(input.bind_data); + + auto &bind_data = input.bind_data->Cast(); auto &table = bind_data.table; auto &storage = table.GetStorage(); - auto &config = ClientConfig::GetConfig(context); - if (!config.enable_optimizer) { - // we only push index scans if the optimizer is enabled - return; + // Can't index scan without filters. + if (!input.filters) { + return DuckTableScanInitGlobal(context, input, storage, bind_data); } - if (bind_data.is_index_scan) { - return; - } - if (!get.table_filters.filters.empty()) { - // if there were filters before we can't convert this to an index scan - return; - } - if (!get.projection_ids.empty()) { - // if columns were pruned by RemoveUnusedColumns we can't convert this to an index scan, - // because index scan does not support filter_prune (yet) - return; - } - if (filters.empty()) { - // no indexes or no filters: skip the pushdown - return; + auto &filter_set = *input.filters; + + // FIXME: We currently only support scanning one ART with one filter. + // If multiple filters exist, i.e., a = 11 AND b = 24, we need to + // 1. 1.1. Find + scan one ART for a = 11. + // 1.2. Find + scan one ART for b = 24. + // 1.3. Return the intersecting row IDs. + // 2. (Reorder and) scan a single ART with a compound key of (a, b). + if (filter_set.filters.size() != 1) { + return DuckTableScanInitGlobal(context, input, storage, bind_data); } + // The checkpoint lock ensures that we do not checkpoint while scanning this table. auto checkpoint_lock = storage.GetSharedCheckpointLock(); auto &info = storage.GetDataTableInfo(); + auto &indexes = info->GetIndexes(); + if (indexes.Empty()) { + return DuckTableScanInitGlobal(context, input, storage, bind_data); + } - // bind and scan any ART indexes - info->GetIndexes().BindAndScan(context, *info, [&](ART &art_index) { - // first rewrite the index expression so the ColumnBindings align with the column bindings of the current table - if (art_index.unbound_expressions.size() > 1) { - // NOTE: index scans are not (yet) supported for compound index keys - return false; - } + auto &db_config = DBConfig::GetConfig(context); + auto scan_percentage = db_config.GetSetting(context); + auto scan_max_count = db_config.GetSetting(context); - auto index_expression = art_index.unbound_expressions[0]->Copy(); - bool rewrite_possible = true; - RewriteIndexExpression(art_index, get, *index_expression, rewrite_possible); - if (!rewrite_possible) { - // could not rewrite! - return false; - } + auto total_rows = storage.GetTotalRows(); + auto total_rows_from_percentage = LossyNumericCast(double(total_rows) * scan_percentage); + auto max_count = MaxValue(scan_max_count, total_rows_from_percentage); - // Try to find a matching index for any of the filter expressions. - for (auto &filter : filters) { - auto index_state = art_index.TryInitializeScan(*index_expression, *filter); - if (index_state != nullptr) { - - auto &db_config = DBConfig::GetConfig(context); - auto index_scan_percentage = db_config.GetSetting(context); - auto index_scan_max_count = db_config.GetSetting(context); - - auto total_rows = storage.GetTotalRows(); - auto total_rows_from_percentage = LossyNumericCast(double(total_rows) * index_scan_percentage); - auto max_count = MaxValue(index_scan_max_count, total_rows_from_percentage); - - // Check if we can use an index scan, and already retrieve the matching row ids. - if (art_index.Scan(*index_state, max_count, bind_data.row_ids)) { - bind_data.is_index_scan = true; - get.function = TableScanFunction::GetIndexScanFunction(); - return true; - } - - // Clear the row ids in case we exceeded the maximum count and stopped scanning. - bind_data.row_ids.clear(); - return true; - } - } - return false; + auto &column_list = table.GetColumns(); + bool index_scan = false; + unsafe_vector row_ids; + + info->GetIndexes().BindAndScan(context, *info, [&](ART &art) { + index_scan = TryScanIndex(art, column_list, input, filter_set, max_count, row_ids); + return index_scan; }); + + if (!index_scan) { + return DuckTableScanInitGlobal(context, input, storage, bind_data); + } + return DuckIndexScanInitGlobal(context, input, storage, bind_data, row_ids); +} + +static unique_ptr TableScanStatistics(ClientContext &context, const FunctionData *bind_data_p, + column_t column_id) { + auto &bind_data = bind_data_p->Cast(); + auto &local_storage = LocalStorage::Get(context, bind_data.table.catalog); + + // Don't emit statistics for tables with outstanding transaction-local data. + if (local_storage.Find(bind_data.table.GetStorage())) { + return nullptr; + } + return bind_data.table.GetStatistics(context, column_id); +} + +static void TableScanFunc(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) { + auto &g_state = data_p.global_state->Cast(); + g_state.TableScanFunc(context, data_p, output); +} + +double TableScanProgress(ClientContext &context, const FunctionData *bind_data_p, + const GlobalTableFunctionState *g_state_p) { + auto &g_state = g_state_p->Cast(); + return g_state.TableScanProgress(context, bind_data_p); +} + +OperatorPartitionData TableScanGetPartitionData(ClientContext &context, TableFunctionGetPartitionInput &input) { + if (input.partition_info.RequiresPartitionColumns()) { + throw InternalException("TableScan::GetPartitionData: partition columns not supported"); + } + + auto &g_state = input.global_state->Cast(); + return g_state.TableScanGetPartitionData(context, input); +} + +vector TableScanGetPartitionStats(ClientContext &context, GetPartitionStatsInput &input) { + auto &bind_data = input.bind_data->Cast(); + vector result; + auto &storage = bind_data.table.GetStorage(); + return storage.GetPartitionStats(context); +} + +BindInfo TableScanGetBindInfo(const optional_ptr bind_data_p) { + auto &bind_data = bind_data_p->Cast(); + return BindInfo(bind_data.table); +} + +void TableScanDependency(LogicalDependencyList &entries, const FunctionData *bind_data_p) { + auto &bind_data = bind_data_p->Cast(); + entries.AddDependency(bind_data.table); +} + +unique_ptr TableScanCardinality(ClientContext &context, const FunctionData *bind_data_p) { + auto &bind_data = bind_data_p->Cast(); + auto &local_storage = LocalStorage::Get(context, bind_data.table.catalog); + auto &storage = bind_data.table.GetStorage(); + idx_t table_rows = storage.GetTotalRows(); + idx_t estimated_cardinality = table_rows + local_storage.AddedRows(bind_data.table.GetStorage()); + return make_uniq(table_rows, estimated_cardinality); } InsertionOrderPreservingMap TableScanToString(TableFunctionToStringInput &input) { InsertionOrderPreservingMap result; auto &bind_data = input.bind_data->Cast(); result["Table"] = bind_data.table.name; + result["Type"] = bind_data.is_index_scan ? "Index Scan" : "Sequence Scan"; return result; } @@ -408,7 +591,7 @@ static void TableScanSerialize(Serializer &serializer, const optional_ptr()); } static unique_ptr TableScanDeserialize(Deserializer &deserializer, TableFunction &function) { @@ -423,30 +606,10 @@ static unique_ptr TableScanDeserialize(Deserializer &deserializer, auto result = make_uniq(catalog_entry.Cast()); deserializer.ReadProperty(103, "is_index_scan", result->is_index_scan); deserializer.ReadProperty(104, "is_create_index", result->is_create_index); - deserializer.ReadProperty(105, "result_ids", result->row_ids); + deserializer.ReadDeletedProperty>(105, "result_ids"); return std::move(result); } -TableFunction TableScanFunction::GetIndexScanFunction() { - TableFunction scan_function("index_scan", {}, IndexScanFunction); - scan_function.init_local = nullptr; - scan_function.init_global = IndexScanInitGlobal; - scan_function.statistics = TableScanStatistics; - scan_function.dependency = TableScanDependency; - scan_function.cardinality = TableScanCardinality; - scan_function.pushdown_complex_filter = nullptr; - scan_function.to_string = TableScanToString; - scan_function.table_scan_progress = nullptr; - scan_function.get_partition_data = nullptr; - scan_function.projection_pushdown = true; - scan_function.filter_pushdown = false; - scan_function.get_bind_info = TableScanGetBindInfo; - scan_function.serialize = TableScanSerialize; - scan_function.deserialize = TableScanDeserialize; - scan_function.get_partition_stats = nullptr; - return scan_function; -} - TableFunction TableScanFunction::GetFunction() { TableFunction scan_function("seq_scan", {}, TableScanFunc); scan_function.init_local = TableScanInitLocal; @@ -454,7 +617,7 @@ TableFunction TableScanFunction::GetFunction() { scan_function.statistics = TableScanStatistics; scan_function.dependency = TableScanDependency; scan_function.cardinality = TableScanCardinality; - scan_function.pushdown_complex_filter = TableScanPushdownComplexFilter; + scan_function.pushdown_complex_filter = nullptr; scan_function.to_string = TableScanToString; scan_function.table_scan_progress = TableScanProgress; scan_function.get_partition_data = TableScanGetPartitionData; @@ -473,8 +636,6 @@ void TableScanFunction::RegisterFunction(BuiltinFunctions &set) { TableFunctionSet table_scan_set("seq_scan"); table_scan_set.AddFunction(GetFunction()); set.AddFunction(std::move(table_scan_set)); - - set.AddFunction(GetIndexScanFunction()); } void BuiltinFunctions::RegisterTableScanFunctions() { diff --git a/src/duckdb/src/function/table/version/pragma_version.cpp b/src/duckdb/src/function/table/version/pragma_version.cpp index a98a327c6..19507ffef 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 "4-dev4271" +#define DUCKDB_PATCH_VERSION "4-dev4308" #endif #ifndef DUCKDB_MINOR_VERSION #define DUCKDB_MINOR_VERSION 1 @@ -8,10 +8,10 @@ #define DUCKDB_MAJOR_VERSION 1 #endif #ifndef DUCKDB_VERSION -#define DUCKDB_VERSION "v1.1.4-dev4271" +#define DUCKDB_VERSION "v1.1.4-dev4308" #endif #ifndef DUCKDB_SOURCE_ID -#define DUCKDB_SOURCE_ID "d707b4432b" +#define DUCKDB_SOURCE_ID "cb8ecb6b96" #endif #include "duckdb/function/table/system_functions.hpp" #include "duckdb/main/database.hpp" diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry/type_catalog_entry.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry/type_catalog_entry.hpp index 8d608d074..3b479541b 100644 --- a/src/duckdb/src/include/duckdb/catalog/catalog_entry/type_catalog_entry.hpp +++ b/src/duckdb/src/include/duckdb/catalog/catalog_entry/type_catalog_entry.hpp @@ -27,7 +27,7 @@ class TypeCatalogEntry : public StandardEntry { LogicalType user_type; - bind_type_modifiers_function_t bind_modifiers; + bind_logical_type_function_t bind_function; public: unique_ptr GetInfo() const override; diff --git a/src/duckdb/src/include/duckdb/common/extension_type_info.hpp b/src/duckdb/src/include/duckdb/common/extension_type_info.hpp index 48e12d3c3..b8ee0f440 100644 --- a/src/duckdb/src/include/duckdb/common/extension_type_info.hpp +++ b/src/duckdb/src/include/duckdb/common/extension_type_info.hpp @@ -2,18 +2,36 @@ #include "duckdb/common/string.hpp" #include "duckdb/common/types/value.hpp" -#include "duckdb/common/serializer/serializer.hpp" namespace duckdb { +class Serializer; +class Deserializer; + +struct LogicalTypeModifier { +public: + explicit LogicalTypeModifier(Value value_p) : value(std::move(value_p)) { + } + string ToString() const { + return label.empty() ? value.ToString() : label; + } + +public: + Value value; + string label; + + void Serialize(Serializer &serializer) const; + static LogicalTypeModifier Deserialize(Deserializer &source); +}; + struct ExtensionTypeInfo { - vector modifiers; + vector modifiers; unordered_map properties; public: void Serialize(Serializer &serializer) const; static unique_ptr Deserialize(Deserializer &source); - bool Equals(optional_ptr other_p) const; + static bool Equals(optional_ptr rhs, optional_ptr lhs); }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/function/table/table_scan.hpp b/src/duckdb/src/include/duckdb/function/table/table_scan.hpp index 23015d33f..e5c88e84f 100644 --- a/src/duckdb/src/include/duckdb/function/table/table_scan.hpp +++ b/src/duckdb/src/include/duckdb/function/table/table_scan.hpp @@ -20,28 +20,26 @@ struct TableScanBindData : public TableFunctionData { explicit TableScanBindData(DuckTableEntry &table) : table(table), is_index_scan(false), is_create_index(false) { } - //! The table to scan + //! The table to scan. DuckTableEntry &table; - - //! Whether or not the table scan is an index scan. + //! The old purpose of this field has been deprecated. + //! We now use it to express an index scan in the ANALYZE call. + //! I.e., we const-cast the bind data and set this to true, if we opt for an index scan. bool is_index_scan; //! Whether or not the table scan is for index creation. bool is_create_index; - //! The row ids to fetch in case of an index scan. - unsafe_vector row_ids; public: bool Equals(const FunctionData &other_p) const override { auto &other = other_p.Cast(); - return &other.table == &table && row_ids == other.row_ids; + return &other.table == &table; } }; -//! The table scan function represents a sequential scan over one of DuckDB's base tables. +//! The table scan function represents a sequential or index scan over one of DuckDB's base tables. struct TableScanFunction { static void RegisterFunction(BuiltinFunctions &set); static TableFunction GetFunction(); - static TableFunction GetIndexScanFunction(); }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/function/table_function.hpp b/src/duckdb/src/include/duckdb/function/table_function.hpp index c2facd064..6293100ef 100644 --- a/src/duckdb/src/include/duckdb/function/table_function.hpp +++ b/src/duckdb/src/include/duckdb/function/table_function.hpp @@ -115,6 +115,7 @@ struct TableFunctionInitInput { column_indexes.emplace_back(col_id); } } + TableFunctionInitInput(optional_ptr bind_data_p, vector column_indexes_p, const vector &projection_ids_p, optional_ptr filters_p, optional_ptr sample_options_p = nullptr) @@ -134,15 +135,15 @@ struct TableFunctionInitInput { bool CanRemoveFilterColumns() const { if (projection_ids.empty()) { - // Not set, can't remove filter columns + // No filter columns to remove. return false; - } else if (projection_ids.size() == column_ids.size()) { - // Filter column is used in remainder of plan, can't remove + } + if (projection_ids.size() == column_ids.size()) { + // Filter column is used in remainder of plan, so we cannot remove it. return false; - } else { - // Less columns need to be projected out than that we scan - return true; } + // Fewer columns need to be projected out than that we scan. + return true; } }; diff --git a/src/duckdb/src/include/duckdb/main/extension_util.hpp b/src/duckdb/src/include/duckdb/main/extension_util.hpp index 6bdd7fa6d..598320b82 100644 --- a/src/duckdb/src/include/duckdb/main/extension_util.hpp +++ b/src/duckdb/src/include/duckdb/main/extension_util.hpp @@ -69,7 +69,7 @@ class ExtensionUtil { //! Registers a new type DUCKDB_API static void RegisterType(DatabaseInstance &db, string type_name, LogicalType type, - bind_type_modifiers_function_t bind_type_modifiers = nullptr); + bind_logical_type_function_t bind_function = nullptr); //! Registers a new secret type DUCKDB_API static void RegisterSecretType(DatabaseInstance &db, SecretType secret_type); diff --git a/src/duckdb/src/include/duckdb/main/profiling_info.hpp b/src/duckdb/src/include/duckdb/main/profiling_info.hpp index 5e9ee287b..a57166153 100644 --- a/src/duckdb/src/include/duckdb/main/profiling_info.hpp +++ b/src/duckdb/src/include/duckdb/main/profiling_info.hpp @@ -60,8 +60,8 @@ class ProfilingInfo { public: template - METRIC_TYPE GetMetricValue(const MetricsType setting) const { - auto val = metrics.at(setting); + METRIC_TYPE GetMetricValue(const MetricsType type) const { + auto val = metrics.at(type); return val.GetValue(); } diff --git a/src/duckdb/src/include/duckdb/main/query_profiler.hpp b/src/duckdb/src/include/duckdb/main/query_profiler.hpp index bbeb8400e..1de54e9a1 100644 --- a/src/duckdb/src/include/duckdb/main/query_profiler.hpp +++ b/src/duckdb/src/include/duckdb/main/query_profiler.hpp @@ -43,6 +43,7 @@ struct OperatorInformation { idx_t elements_returned; idx_t result_set_size; string name; + InsertionOrderPreservingMap extra_info; void AddTime(double n_time) { time += n_time; @@ -88,8 +89,8 @@ class OperatorProfiler { Profiler op; //! The stack of Physical Operators that are currently active optional_ptr active_operator; - //! A mapping of physical operators to recorded timings - reference_map_t timings; + //! A mapping of physical operators to profiled operator information. + reference_map_t operator_infos; }; struct QueryInfo { 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 00551cb46..6b50064a1 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 @@ -15,18 +15,18 @@ namespace duckdb { -struct BindTypeModifiersInput { +struct BindLogicalTypeInput { ClientContext &context; - const LogicalType &type; + const LogicalType &base_type; const vector &modifiers; }; //! The type to bind type modifiers to a type -typedef LogicalType (*bind_type_modifiers_function_t)(BindTypeModifiersInput &input); +typedef LogicalType (*bind_logical_type_function_t)(const BindLogicalTypeInput &input); struct CreateTypeInfo : public CreateInfo { CreateTypeInfo(); - CreateTypeInfo(string name_p, LogicalType type_p, bind_type_modifiers_function_t bind_modifiers_p = nullptr); + CreateTypeInfo(string name_p, LogicalType type_p, bind_logical_type_function_t bind_function_p = nullptr); //! Name of the Type string name; @@ -35,7 +35,7 @@ struct CreateTypeInfo : public CreateInfo { //! Used by create enum from query unique_ptr query; //! Bind type modifiers to the type - bind_type_modifiers_function_t bind_modifiers; + bind_logical_type_function_t bind_function; public: unique_ptr Copy() const override; diff --git a/src/duckdb/src/include/duckdb/planner/filter/in_filter.hpp b/src/duckdb/src/include/duckdb/planner/filter/in_filter.hpp index c9028ed5e..19e3862a3 100644 --- a/src/duckdb/src/include/duckdb/planner/filter/in_filter.hpp +++ b/src/duckdb/src/include/duckdb/planner/filter/in_filter.hpp @@ -19,8 +19,10 @@ class InFilter : public TableFilter { public: explicit InFilter(vector values); + InFilter(vector values, bool origin_is_hash_join); vector values; + bool origin_is_hash_join; public: FilterPropagateResult CheckStatistics(BaseStatistics &stats) override; diff --git a/src/duckdb/src/main/extension/extension_util.cpp b/src/duckdb/src/main/extension/extension_util.cpp index 609fd4b7d..65e099d7e 100644 --- a/src/duckdb/src/main/extension/extension_util.cpp +++ b/src/duckdb/src/main/extension/extension_util.cpp @@ -184,7 +184,7 @@ TableFunctionCatalogEntry &ExtensionUtil::GetTableFunction(DatabaseInstance &db, } void ExtensionUtil::RegisterType(DatabaseInstance &db, string type_name, LogicalType type, - bind_type_modifiers_function_t bind_modifiers) { + bind_logical_type_function_t bind_modifiers) { D_ASSERT(!type_name.empty()); CreateTypeInfo info(std::move(type_name), std::move(type), bind_modifiers); info.temporary = true; diff --git a/src/duckdb/src/main/query_profiler.cpp b/src/duckdb/src/main/query_profiler.cpp index 99f7a40a5..03889af52 100644 --- a/src/duckdb/src/main/query_profiler.cpp +++ b/src/duckdb/src/main/query_profiler.cpp @@ -372,9 +372,17 @@ void OperatorProfiler::StartOperator(optional_ptr phys_o } active_operator = phys_op; - // Start the timing of the current operator. - if (ProfilingInfo::Enabled(settings, MetricsType::OPERATOR_TIMING)) { - op.Start(); + if (!settings.empty()) { + if (ProfilingInfo::Enabled(settings, MetricsType::EXTRA_INFO)) { + auto &info = GetOperatorInfo(*active_operator); + auto params = active_operator->ParamsToString(); + info.extra_info = params; + } + + // Start the timing of the current operator. + if (ProfilingInfo::Enabled(settings, MetricsType::OPERATOR_TIMING)) { + op.Start(); + } } } @@ -404,22 +412,24 @@ void OperatorProfiler::EndOperator(optional_ptr chunk) { } OperatorInformation &OperatorProfiler::GetOperatorInfo(const PhysicalOperator &phys_op) { - auto entry = timings.find(phys_op); - if (entry != timings.end()) { + auto entry = operator_infos.find(phys_op); + if (entry != operator_infos.end()) { return entry->second; } + // Add a new entry. - timings[phys_op] = OperatorInformation(); - return timings[phys_op]; + operator_infos[phys_op] = OperatorInformation(); + return operator_infos[phys_op]; } void OperatorProfiler::Flush(const PhysicalOperator &phys_op) { - auto entry = timings.find(phys_op); - if (entry == timings.end()) { + auto entry = operator_infos.find(phys_op); + if (entry == operator_infos.end()) { return; } - auto &operator_timing = timings.find(phys_op)->second; - operator_timing.name = phys_op.GetName(); + + auto &info = operator_infos.find(phys_op)->second; + info.name = phys_op.GetName(); } void QueryProfiler::Flush(OperatorProfiler &profiler) { @@ -427,7 +437,7 @@ void QueryProfiler::Flush(OperatorProfiler &profiler) { if (!IsEnabled() || !running) { return; } - for (auto &node : profiler.timings) { + for (auto &node : profiler.operator_infos) { auto &op = node.first.get(); auto entry = tree_map.find(op); D_ASSERT(entry != tree_map.end()); @@ -457,8 +467,11 @@ void QueryProfiler::Flush(OperatorProfiler &profiler) { if (ProfilingInfo::Enabled(profiler.settings, MetricsType::RESULT_SET_SIZE)) { info.AddToMetric(MetricsType::RESULT_SET_SIZE, node.second.result_set_size); } + if (ProfilingInfo::Enabled(profiler.settings, MetricsType::EXTRA_INFO)) { + info.extra_info = node.second.extra_info; + } } - profiler.timings.clear(); + profiler.operator_infos.clear(); } void QueryProfiler::SetInfo(const double &blocked_thread_time) { 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 3c0472c9f..1ce0327c3 100644 --- a/src/duckdb/src/parser/parsed_data/create_type_info.cpp +++ b/src/duckdb/src/parser/parsed_data/create_type_info.cpp @@ -6,11 +6,11 @@ namespace duckdb { -CreateTypeInfo::CreateTypeInfo() : CreateInfo(CatalogType::TYPE_ENTRY), bind_modifiers(nullptr) { +CreateTypeInfo::CreateTypeInfo() : CreateInfo(CatalogType::TYPE_ENTRY), bind_function(nullptr) { } -CreateTypeInfo::CreateTypeInfo(string name_p, LogicalType type_p, bind_type_modifiers_function_t bind_modifiers_p) +CreateTypeInfo::CreateTypeInfo(string name_p, LogicalType type_p, bind_logical_type_function_t bind_function_p) : CreateInfo(CatalogType::TYPE_ENTRY), name(std::move(name_p)), type(std::move(type_p)), - bind_modifiers(bind_modifiers_p) { + bind_function(bind_function_p) { } unique_ptr CreateTypeInfo::Copy() const { @@ -21,7 +21,7 @@ unique_ptr CreateTypeInfo::Copy() const { if (query) { result->query = query->Copy(); } - result->bind_modifiers = bind_modifiers; + result->bind_function = bind_function; return std::move(result); } diff --git a/src/duckdb/src/planner/binder/statement/bind_create.cpp b/src/duckdb/src/planner/binder/statement/bind_create.cpp index 8d53446fc..49c2f37b7 100644 --- a/src/duckdb/src/planner/binder/statement/bind_create.cpp +++ b/src/duckdb/src/planner/binder/statement/bind_create.cpp @@ -308,7 +308,7 @@ void Binder::BindLogicalType(LogicalType &type, optional_ptr catalog, c auto user_type_schema = UserType::GetSchema(type); auto user_type_mods = UserType::GetTypeModifiers(type); - bind_type_modifiers_function_t user_bind_modifiers_func = nullptr; + bind_logical_type_function_t user_bind_modifiers_func = nullptr; if (catalog) { // The search order is: @@ -336,7 +336,7 @@ void Binder::BindLogicalType(LogicalType &type, optional_ptr catalog, c } auto &type_entry = entry->Cast(); type = type_entry.user_type; - user_bind_modifiers_func = type_entry.bind_modifiers; + user_bind_modifiers_func = type_entry.bind_function; } else { string type_catalog = UserType::GetCatalog(type); string type_schema = UserType::GetSchema(type); @@ -345,7 +345,7 @@ void Binder::BindLogicalType(LogicalType &type, optional_ptr catalog, c auto entry = entry_retriever.GetEntry(CatalogType::TYPE_ENTRY, type_catalog, type_schema, user_type_name); auto &type_entry = entry->Cast(); type = type_entry.user_type; - user_bind_modifiers_func = type_entry.bind_modifiers; + user_bind_modifiers_func = type_entry.bind_function; } // Now we bind the inner user type @@ -354,45 +354,13 @@ void Binder::BindLogicalType(LogicalType &type, optional_ptr catalog, c // 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 - BindTypeModifiersInput input {context, type, user_type_mods}; - type = user_bind_modifiers_func(input); - } else if (type.HasExtensionInfo()) { - auto &ext_info = *type.GetExtensionInfo(); - - // If the type already has modifiers, try to replace them with the user-provided ones if they are compatible - // This enables registering custom types with "default" type modifiers that can be overridden, without - // having to provide a custom bind_modifiers function - auto type_mods_size = ext_info.modifiers.size(); - - // Are we trying to pass more type modifiers than the type has? - if (user_type_mods.size() > type_mods_size) { - throw BinderException( - "Cannot apply '%d' type modifier(s) to type '%s' taking at most '%d' type modifier(s)", - user_type_mods.size(), user_type_name, type_mods_size); - } - // Deep copy the type so that we can replace the type modifiers - type = type.DeepCopy(); - - // Re-fetch the type modifiers now that we've deduplicated the ExtraTypeInfo - auto &type_mods = type.GetExtensionInfo()->modifiers; - - // Replace them in order, casting if necessary - for (idx_t i = 0; i < MinValue(type_mods.size(), user_type_mods.size()); i++) { - auto &type_mod = type_mods[i]; - auto user_type_mod = user_type_mods[i]; - if (type_mod.type() == user_type_mod.type()) { - type_mod = std::move(user_type_mod); - } else if (user_type_mod.DefaultTryCastAs(type_mod.type())) { - type_mod = std::move(user_type_mod); - } else { - throw BinderException("Cannot apply type modifier '%s' to type '%s', expected value of type '%s'", - user_type_mod.ToString(), user_type_name, type_mod.type().ToString()); - } + BindLogicalTypeInput input {context, type, user_type_mods}; + type = user_bind_modifiers_func(input); + } else { + if (!user_type_mods.empty()) { + throw BinderException("Type '%s' does not take any type modifiers", user_type_name); } - } else if (!user_type_mods.empty()) { - // We're trying to pass type modifiers to a type that doesnt have any - throw BinderException("Type '%s' does not take any type modifiers", user_type_name); } } diff --git a/src/duckdb/src/planner/filter/in_filter.cpp b/src/duckdb/src/planner/filter/in_filter.cpp index 9c848292a..b3eff6e23 100644 --- a/src/duckdb/src/planner/filter/in_filter.cpp +++ b/src/duckdb/src/planner/filter/in_filter.cpp @@ -5,7 +5,11 @@ namespace duckdb { -InFilter::InFilter(vector values_p) : TableFilter(TableFilterType::IN_FILTER), values(std::move(values_p)) { +InFilter::InFilter(vector values_p) : InFilter(std::move(values_p), false) { +} + +InFilter::InFilter(vector values_p, bool origin_is_hash_join) + : TableFilter(TableFilterType::IN_FILTER), values(std::move(values_p)), origin_is_hash_join(origin_is_hash_join) { for (auto &val : values) { if (val.IsNull()) { throw InternalException("InFilter constant cannot be NULL - use IsNullFilter instead"); @@ -70,11 +74,11 @@ bool InFilter::Equals(const TableFilter &other_p) const { return false; } auto &other = other_p.Cast(); - return other.values == values; + return other.values == values && other.origin_is_hash_join == origin_is_hash_join; } unique_ptr InFilter::Copy() const { - return make_uniq(values); + return make_uniq(values, origin_is_hash_join); } } // namespace duckdb diff --git a/src/duckdb/src/storage/serialization/serialize_types.cpp b/src/duckdb/src/storage/serialization/serialize_types.cpp index 34f48bdec..6f5e811ef 100644 --- a/src/duckdb/src/storage/serialization/serialize_types.cpp +++ b/src/duckdb/src/storage/serialization/serialize_types.cpp @@ -122,13 +122,13 @@ shared_ptr DecimalTypeInfo::Deserialize(Deserializer &deserialize } void ExtensionTypeInfo::Serialize(Serializer &serializer) const { - serializer.WritePropertyWithDefault>(100, "modifiers", modifiers); + serializer.WritePropertyWithDefault>(100, "modifiers", modifiers); serializer.WritePropertyWithDefault>(101, "properties", properties, unordered_map()); } unique_ptr ExtensionTypeInfo::Deserialize(Deserializer &deserializer) { auto result = duckdb::unique_ptr(new ExtensionTypeInfo()); - deserializer.ReadPropertyWithDefault>(100, "modifiers", result->modifiers); + deserializer.ReadPropertyWithDefault>(100, "modifiers", result->modifiers); deserializer.ReadPropertyWithExplicitDefault>(101, "properties", result->properties, unordered_map()); return result; } @@ -155,6 +155,18 @@ shared_ptr ListTypeInfo::Deserialize(Deserializer &deserializer) return std::move(result); } +void LogicalTypeModifier::Serialize(Serializer &serializer) const { + serializer.WriteProperty(100, "value", value); + serializer.WritePropertyWithDefault(101, "label", label); +} + +LogicalTypeModifier LogicalTypeModifier::Deserialize(Deserializer &deserializer) { + auto value = deserializer.ReadProperty(100, "value"); + LogicalTypeModifier result(value); + deserializer.ReadPropertyWithDefault(101, "label", result.label); + return result; +} + void StringTypeInfo::Serialize(Serializer &serializer) const { ExtraTypeInfo::Serialize(serializer); serializer.WritePropertyWithDefault(200, "collation", collation); From 55641c4f9e46ab73c7940c58c7f4b457c88890f2 Mon Sep 17 00:00:00 2001 From: DuckDB Labs GitHub Bot Date: Sun, 12 Jan 2025 00:37:40 +0000 Subject: [PATCH 10/16] Update vendored DuckDB sources to ad63b51e --- .../extension/parquet/column_writer.cpp | 159 ++++++++++++++++-- .../parquet/include/parquet_bss_encoder.hpp | 45 +++++ .../parquet/include/parquet_dlba_encoder.hpp | 48 ++++++ .../src/common/serializer/memory_stream.cpp | 36 ++++ .../aggregate/sorted_aggregate_function.cpp | 78 +++++++-- .../function/table/version/pragma_version.cpp | 6 +- .../window/window_aggregate_function.cpp | 2 +- .../window/window_constant_aggregator.cpp | 19 ++- .../src/function/window/window_executor.cpp | 4 - .../function/window/window_rank_function.cpp | 4 + .../window/window_rownumber_function.cpp | 4 + .../function/window/window_value_function.cpp | 4 + .../common/serializer/memory_stream.hpp | 7 + .../duckdb/function/function_binder.hpp | 1 + .../window/window_constant_aggregator.hpp | 4 +- .../function/window/window_executor.hpp | 3 - .../function/window/window_rank_function.hpp | 3 + .../window/window_rownumber_function.hpp | 2 + .../function/window/window_value_function.hpp | 2 + .../duckdb/planner/bound_result_modifier.hpp | 1 + .../src/planner/bound_result_modifier.cpp | 8 +- 21 files changed, 390 insertions(+), 50 deletions(-) create mode 100644 src/duckdb/extension/parquet/include/parquet_bss_encoder.hpp create mode 100644 src/duckdb/extension/parquet/include/parquet_dlba_encoder.hpp diff --git a/src/duckdb/extension/parquet/column_writer.cpp b/src/duckdb/extension/parquet/column_writer.cpp index ac854497d..677bacf42 100644 --- a/src/duckdb/extension/parquet/column_writer.cpp +++ b/src/duckdb/extension/parquet/column_writer.cpp @@ -3,8 +3,10 @@ #include "duckdb.hpp" #include "geo_parquet.hpp" #include "parquet_dbp_encoder.hpp" +#include "parquet_dlba_encoder.hpp" #include "parquet_rle_bp_decoder.hpp" #include "parquet_rle_bp_encoder.hpp" +#include "parquet_bss_encoder.hpp" #include "parquet_statistics.hpp" #include "parquet_writer.hpp" #ifndef DUCKDB_AMALGAMATION @@ -1059,34 +1061,42 @@ class StandardColumnWriterState : public BasicColumnWriterState { } ~StandardColumnWriterState() override = default; - // analysis state for integer values for DELTA_BINARY_PACKED + // analysis state for integer values for DELTA_BINARY_PACKED/DELTA_LENGTH_BYTE_ARRAY idx_t total_value_count = 0; + idx_t total_string_size = 0; unordered_map dictionary; duckdb_parquet::Encoding::type encoding; }; -template +template class StandardWriterPageState : public ColumnWriterPageState { public: - explicit StandardWriterPageState(const idx_t total_value_count, Encoding::type encoding_p, - const unordered_map &dictionary_p) - : encoding(encoding_p), dbp_initialized(false), dbp_encoder(total_value_count), dictionary(dictionary_p), - dict_written_value(false), dict_bit_width(RleBpDecoder::ComputeBitWidth(dictionary.size())), - dict_encoder(dict_bit_width) { + explicit StandardWriterPageState(const idx_t total_value_count, const idx_t total_string_size, + Encoding::type encoding_p, const unordered_map &dictionary_p) + : encoding(encoding_p), dbp_initialized(false), dbp_encoder(total_value_count), dlba_initialized(false), + dlba_encoder(total_value_count, total_string_size), bss_encoder(total_value_count, sizeof(TGT)), + dictionary(dictionary_p), dict_written_value(false), + dict_bit_width(RleBpDecoder::ComputeBitWidth(dictionary.size())), dict_encoder(dict_bit_width) { } duckdb_parquet::Encoding::type encoding; bool dbp_initialized; DbpEncoder dbp_encoder; - const unordered_map &dictionary; + bool dlba_initialized; + DlbaEncoder dlba_encoder; + + BssEncoder bss_encoder; + + const unordered_map &dictionary; bool dict_written_value; uint32_t dict_bit_width; RleBpEncoder dict_encoder; }; namespace dbp_encoder { + template void BeginWrite(DbpEncoder &encoder, WriteStream &writer, const T &first_value) { throw InternalException("Can't write type to DELTA_BINARY_PACKED column"); @@ -1139,6 +1149,60 @@ void WriteValue(DbpEncoder &encoder, WriteStream &writer, const uint32_t &value) } // namespace dbp_encoder +namespace dlba_encoder { + +template +void BeginWrite(DlbaEncoder &encoder, WriteStream &writer, const T &first_value) { + throw InternalException("Can't write type to DELTA_LENGTH_BYTE_ARRAY column"); +} + +template <> +void BeginWrite(DlbaEncoder &encoder, WriteStream &writer, const string_t &first_value) { + encoder.BeginWrite(writer, first_value); +} + +template +void WriteValue(DlbaEncoder &encoder, WriteStream &writer, const T &value) { + throw InternalException("Can't write type to DELTA_LENGTH_BYTE_ARRAY column"); +} + +template <> +void WriteValue(DlbaEncoder &encoder, WriteStream &writer, const string_t &value) { + encoder.WriteValue(writer, value); +} + +// helpers to get size from strings +template +static constexpr idx_t GetDlbaStringSize(const SRC &src_value) { + return 0; +} + +template <> +idx_t GetDlbaStringSize(const string_t &src_value) { + return src_value.GetSize(); +} + +} // namespace dlba_encoder + +namespace bss_encoder { + +template +void WriteValue(BssEncoder &encoder, const T &value) { + throw InternalException("Can't write type to BYTE_STREAM_SPLIT column"); +} + +template <> +void WriteValue(BssEncoder &encoder, const float &value) { + encoder.WriteValue(value); +} + +template <> +void WriteValue(BssEncoder &encoder, const double &value) { + encoder.WriteValue(value); +} + +} // namespace bss_encoder + template class StandardColumnWriter : public BasicColumnWriter { public: @@ -1159,13 +1223,13 @@ class StandardColumnWriter : public BasicColumnWriter { unique_ptr InitializePageState(BasicColumnWriterState &state_p) override { auto &state = state_p.Cast>(); - auto result = - make_uniq>(state.total_value_count, state.encoding, state.dictionary); + auto result = make_uniq>(state.total_value_count, state.total_string_size, + state.encoding, state.dictionary); return std::move(result); } void FlushPageState(WriteStream &temp_writer, ColumnWriterPageState *state_p) override { - auto &page_state = state_p->Cast>(); + auto &page_state = state_p->Cast>(); switch (page_state.encoding) { case Encoding::DELTA_BINARY_PACKED: if (!page_state.dbp_initialized) { @@ -1182,7 +1246,15 @@ class StandardColumnWriter : public BasicColumnWriter { return; } page_state.dict_encoder.FinishWrite(temp_writer); - + break; + case Encoding::DELTA_LENGTH_BYTE_ARRAY: + if (!page_state.dlba_initialized) { + dlba_encoder::BeginWrite(page_state.dlba_encoder, temp_writer, string_t("")); + } + page_state.dlba_encoder.FinishWrite(temp_writer); + break; + case Encoding::BYTE_STREAM_SPLIT: + page_state.bss_encoder.FinishWrite(temp_writer); break; case Encoding::PLAIN: break; @@ -1220,14 +1292,15 @@ class StandardColumnWriter : public BasicColumnWriter { continue; } if (validity.RowIsValid(vector_index)) { + const auto &src_value = data_ptr[vector_index]; if (state.dictionary.size() <= writer.DictionarySizeLimit()) { - const auto &src_value = data_ptr[vector_index]; if (state.dictionary.find(src_value) == state.dictionary.end()) { state.dictionary[src_value] = new_value_index; new_value_index++; } } state.total_value_count++; + state.total_string_size += dlba_encoder::GetDlbaStringSize(src_value); } vector_index++; } @@ -1238,9 +1311,22 @@ class StandardColumnWriter : public BasicColumnWriter { auto &state = state_p.Cast>(); if (state.dictionary.size() == 0 || state.dictionary.size() > writer.DictionarySizeLimit()) { - // special handling for int column: dpb, otherwise plain - state.encoding = (type == Type::type::INT32 || type == Type::type::INT64) ? Encoding::DELTA_BINARY_PACKED - : Encoding::PLAIN; + // If we aren't doing dictionary encoding, the following encodings are virtually always better than PLAIN + switch (type) { + case Type::type::INT32: + case Type::type::INT64: + state.encoding = Encoding::DELTA_BINARY_PACKED; + break; + case Type::type::BYTE_ARRAY: + state.encoding = Encoding::DELTA_LENGTH_BYTE_ARRAY; + break; + case Type::type::FLOAT: + case Type::type::DOUBLE: + state.encoding = Encoding::BYTE_STREAM_SPLIT; + break; + default: + state.encoding = Encoding::PLAIN; + } state.dictionary.clear(); } } @@ -1261,7 +1347,7 @@ class StandardColumnWriter : public BasicColumnWriter { void WriteVector(WriteStream &temp_writer, ColumnWriterStatistics *stats, ColumnWriterPageState *page_state_p, Vector &input_column, idx_t chunk_start, idx_t chunk_end) override { - auto &page_state = page_state_p->Cast>(); + auto &page_state = page_state_p->Cast>(); const auto &mask = FlatVector::Validity(input_column); const auto *data_ptr = FlatVector::GetData(input_column); @@ -1287,7 +1373,6 @@ class StandardColumnWriter : public BasicColumnWriter { } break; } - case Encoding::DELTA_BINARY_PACKED: { idx_t r = chunk_start; if (!page_state.dbp_initialized) { @@ -1315,6 +1400,44 @@ class StandardColumnWriter : public BasicColumnWriter { } break; } + case Encoding::DELTA_LENGTH_BYTE_ARRAY: { + idx_t r = chunk_start; + if (!page_state.dlba_initialized) { + // find first non-null value + for (; r < chunk_end; r++) { + if (!mask.RowIsValid(r)) { + continue; + } + const TGT target_value = OP::template Operation(data_ptr[r]); + OP::template HandleStats(stats, target_value); + dlba_encoder::BeginWrite(page_state.dlba_encoder, temp_writer, target_value); + page_state.dlba_initialized = true; + r++; // skip over + break; + } + } + + for (; r < chunk_end; r++) { + if (!mask.RowIsValid(r)) { + continue; + } + const TGT target_value = OP::template Operation(data_ptr[r]); + OP::template HandleStats(stats, target_value); + dlba_encoder::WriteValue(page_state.dlba_encoder, temp_writer, target_value); + } + break; + } + case Encoding::BYTE_STREAM_SPLIT: { + for (idx_t r = chunk_start; r < chunk_end; r++) { + if (!mask.RowIsValid(r)) { + continue; + } + const TGT target_value = OP::template Operation(data_ptr[r]); + OP::template HandleStats(stats, target_value); + bss_encoder::WriteValue(page_state.bss_encoder, target_value); + } + break; + } case Encoding::PLAIN: { D_ASSERT(page_state.encoding == Encoding::PLAIN); TemplatedWritePlain(input_column, stats, chunk_start, chunk_end, mask, temp_writer); diff --git a/src/duckdb/extension/parquet/include/parquet_bss_encoder.hpp b/src/duckdb/extension/parquet/include/parquet_bss_encoder.hpp new file mode 100644 index 000000000..80da1726d --- /dev/null +++ b/src/duckdb/extension/parquet/include/parquet_bss_encoder.hpp @@ -0,0 +1,45 @@ +//===----------------------------------------------------------------------===// +// DuckDB +// +// parquet_bss_encoder.hpp +// +// +//===----------------------------------------------------------------------===// + +#pragma once + +#include "decode_utils.hpp" + +namespace duckdb { + +class BssEncoder { +public: + explicit BssEncoder(const idx_t total_value_count_p, const idx_t bit_width_p) + : total_value_count(total_value_count_p), bit_width(bit_width_p), count(0), + buffer(Allocator::DefaultAllocator().Allocate(total_value_count * bit_width + 1)) { + } + +public: + template + void WriteValue(const T &value) { + D_ASSERT(sizeof(T) == bit_width); + for (idx_t i = 0; i < sizeof(T); i++) { + buffer.get()[i * total_value_count + count] = reinterpret_cast(&value)[i]; + } + count++; + } + + void FinishWrite(WriteStream &writer) { + D_ASSERT(count == total_value_count); + writer.WriteData(buffer.get(), total_value_count * bit_width); + } + +private: + const idx_t total_value_count; + const idx_t bit_width; + + idx_t count; + AllocatedData buffer; +}; + +} // namespace duckdb diff --git a/src/duckdb/extension/parquet/include/parquet_dlba_encoder.hpp b/src/duckdb/extension/parquet/include/parquet_dlba_encoder.hpp new file mode 100644 index 000000000..b3cd1aa96 --- /dev/null +++ b/src/duckdb/extension/parquet/include/parquet_dlba_encoder.hpp @@ -0,0 +1,48 @@ +//===----------------------------------------------------------------------===// +// DuckDB +// +// parquet_dlba_encoder.hpp +// +// +//===----------------------------------------------------------------------===// + +#pragma once + +#include "parquet_dbp_encoder.hpp" +#include "duckdb/common/serializer/memory_stream.hpp" + +namespace duckdb { + +class DlbaEncoder { +public: + DlbaEncoder(const idx_t total_value_count_p, const idx_t total_string_size_p) + : dbp_encoder(total_value_count_p), total_string_size(total_string_size_p), + buffer(Allocator::DefaultAllocator().Allocate(total_string_size + 1)), + stream(make_unsafe_uniq(buffer.get(), buffer.GetSize())) { + } + +public: + void BeginWrite(WriteStream &writer, const string_t &first_value) { + dbp_encoder.BeginWrite(writer, UnsafeNumericCast(first_value.GetSize())); + stream->WriteData(const_data_ptr_cast(first_value.GetData()), first_value.GetSize()); + } + + void WriteValue(WriteStream &writer, const string_t &value) { + dbp_encoder.WriteValue(writer, UnsafeNumericCast(value.GetSize())); + stream->WriteData(const_data_ptr_cast(value.GetData()), value.GetSize()); + } + + void FinishWrite(WriteStream &writer) { + D_ASSERT(stream->GetPosition() == total_string_size); + dbp_encoder.FinishWrite(writer); + writer.WriteData(buffer.get(), total_string_size); + } + +private: + DbpEncoder dbp_encoder; + const idx_t total_string_size; + AllocatedData buffer; + unsafe_unique_ptr stream; +}; + +} // namespace duckdb diff --git a/src/duckdb/src/common/serializer/memory_stream.cpp b/src/duckdb/src/common/serializer/memory_stream.cpp index a48696963..e5f0455e3 100644 --- a/src/duckdb/src/common/serializer/memory_stream.cpp +++ b/src/duckdb/src/common/serializer/memory_stream.cpp @@ -21,6 +21,42 @@ MemoryStream::~MemoryStream() { } } +MemoryStream::MemoryStream(MemoryStream &&other) noexcept { + // Move the data from the other stream into this stream + data = other.data; + position = other.position; + capacity = other.capacity; + owns_data = other.owns_data; + + // Reset the other stream + other.data = nullptr; + other.position = 0; + other.capacity = 0; + other.owns_data = false; +} + +MemoryStream &MemoryStream::operator=(MemoryStream &&other) noexcept { + if (this != &other) { + // Free the current data + if (owns_data) { + free(data); + } + + // Move the data from the other stream into this stream + data = other.data; + position = other.position; + capacity = other.capacity; + owns_data = other.owns_data; + + // Reset the other stream + other.data = nullptr; + other.position = 0; + other.capacity = 0; + other.owns_data = false; + } + return *this; +} + void MemoryStream::WriteData(const_data_ptr_t source, idx_t write_size) { while (position + write_size > capacity) { if (owns_data) { diff --git a/src/duckdb/src/function/aggregate/sorted_aggregate_function.cpp b/src/duckdb/src/function/aggregate/sorted_aggregate_function.cpp index 749a3fe36..aa49db798 100644 --- a/src/duckdb/src/function/aggregate/sorted_aggregate_function.cpp +++ b/src/duckdb/src/function/aggregate/sorted_aggregate_function.cpp @@ -4,6 +4,7 @@ #include "duckdb/common/types/list_segment.hpp" #include "duckdb/function/aggregate_function.hpp" #include "duckdb/function/function_binder.hpp" +#include "duckdb/planner/expression/bound_window_expression.hpp" #include "duckdb/storage/buffer_manager.hpp" #include "duckdb/planner/expression/bound_aggregate_expression.hpp" #include "duckdb/planner/expression/bound_constant_expression.hpp" @@ -13,11 +14,15 @@ namespace duckdb { struct SortedAggregateBindData : public FunctionData { - SortedAggregateBindData(ClientContext &context, BoundAggregateExpression &expr) - : buffer_manager(BufferManager::GetBufferManager(context)), function(expr.function), - bind_info(std::move(expr.bind_info)), threshold(ClientConfig::GetConfig(context).ordered_aggregate_threshold), + using Expressions = vector>; + using BindInfoPtr = unique_ptr; + using OrderBys = vector; + + SortedAggregateBindData(ClientContext &context, Expressions &children, AggregateFunction &aggregate, + BindInfoPtr &bind_info, OrderBys &order_bys) + : buffer_manager(BufferManager::GetBufferManager(context)), function(aggregate), + bind_info(std::move(bind_info)), threshold(ClientConfig::GetConfig(context).ordered_aggregate_threshold), external(ClientConfig::GetConfig(context).force_external) { - auto &children = expr.children; arg_types.reserve(children.size()); arg_funcs.reserve(children.size()); for (const auto &child : children) { @@ -26,22 +31,29 @@ struct SortedAggregateBindData : public FunctionData { GetSegmentDataFunctions(funcs, arg_types.back()); arg_funcs.emplace_back(std::move(funcs)); } - auto &order_bys = *expr.order_bys; - sort_types.reserve(order_bys.orders.size()); - sort_funcs.reserve(order_bys.orders.size()); - for (auto &order : order_bys.orders) { + sort_types.reserve(order_bys.size()); + sort_funcs.reserve(order_bys.size()); + for (auto &order : order_bys) { orders.emplace_back(order.Copy()); sort_types.emplace_back(order.expression->return_type); ListSegmentFunctions funcs; GetSegmentDataFunctions(funcs, sort_types.back()); sort_funcs.emplace_back(std::move(funcs)); } - sorted_on_args = (children.size() == order_bys.orders.size()); + sorted_on_args = (children.size() == order_bys.size()); for (size_t i = 0; sorted_on_args && i < children.size(); ++i) { - sorted_on_args = children[i]->Equals(*order_bys.orders[i].expression); + sorted_on_args = children[i]->Equals(*order_bys[i].expression); } } + SortedAggregateBindData(ClientContext &context, BoundAggregateExpression &expr) + : SortedAggregateBindData(context, expr.children, expr.function, expr.bind_info, expr.order_bys->orders) { + } + + SortedAggregateBindData(ClientContext &context, BoundWindowExpression &expr) + : SortedAggregateBindData(context, expr.children, *expr.aggregate, expr.bind_info, expr.arg_orders) { + } + SortedAggregateBindData(const SortedAggregateBindData &other) : buffer_manager(other.buffer_manager), function(other.function), arg_types(other.arg_types), arg_funcs(other.arg_funcs), sort_types(other.sort_types), sort_funcs(other.sort_funcs), @@ -757,4 +769,50 @@ void FunctionBinder::BindSortedAggregate(ClientContext &context, BoundAggregateE expr.order_bys.reset(); } +void FunctionBinder::BindSortedAggregate(ClientContext &context, BoundWindowExpression &expr) { + if (expr.arg_orders.empty() || expr.children.empty()) { + // not a sorted aggregate: return + return; + } + // Remove unnecessary ORDER BY clauses and return if nothing remains + if (context.config.enable_optimizer) { + if (BoundOrderModifier::Simplify(expr.arg_orders, expr.partitions)) { + expr.arg_orders.clear(); + return; + } + } + auto &aggregate = *expr.aggregate; + auto &children = expr.children; + auto &arg_orders = expr.arg_orders; + auto sorted_bind = make_uniq(context, expr); + + if (!sorted_bind->sorted_on_args) { + // The arguments are the children plus the sort columns. + for (auto &order : arg_orders) { + children.emplace_back(std::move(order.expression)); + } + } + + vector arguments; + arguments.reserve(children.size()); + for (const auto &child : children) { + arguments.emplace_back(child->return_type); + } + + // Replace the aggregate with the wrapper + AggregateFunction ordered_aggregate( + aggregate.name, arguments, aggregate.return_type, AggregateFunction::StateSize, + AggregateFunction::StateInitialize, + SortedAggregateFunction::ScatterUpdate, + AggregateFunction::StateCombine, + SortedAggregateFunction::Finalize, aggregate.null_handling, SortedAggregateFunction::SimpleUpdate, nullptr, + AggregateFunction::StateDestroy, nullptr, + SortedAggregateFunction::Window); + + aggregate = std::move(ordered_aggregate); + expr.bind_info = std::move(sorted_bind); + expr.arg_orders.clear(); +} + } // namespace duckdb diff --git a/src/duckdb/src/function/table/version/pragma_version.cpp b/src/duckdb/src/function/table/version/pragma_version.cpp index 19507ffef..bc8341084 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 "4-dev4308" +#define DUCKDB_PATCH_VERSION "4-dev4329" #endif #ifndef DUCKDB_MINOR_VERSION #define DUCKDB_MINOR_VERSION 1 @@ -8,10 +8,10 @@ #define DUCKDB_MAJOR_VERSION 1 #endif #ifndef DUCKDB_VERSION -#define DUCKDB_VERSION "v1.1.4-dev4308" +#define DUCKDB_VERSION "v1.1.4-dev4329" #endif #ifndef DUCKDB_SOURCE_ID -#define DUCKDB_SOURCE_ID "cb8ecb6b96" +#define DUCKDB_SOURCE_ID "a1c7e9b115" #endif #include "duckdb/function/table/system_functions.hpp" #include "duckdb/main/database.hpp" diff --git a/src/duckdb/src/function/window/window_aggregate_function.cpp b/src/duckdb/src/function/window/window_aggregate_function.cpp index 308667601..f08fc5dbc 100644 --- a/src/duckdb/src/function/window/window_aggregate_function.cpp +++ b/src/duckdb/src/function/window/window_aggregate_function.cpp @@ -60,7 +60,7 @@ WindowAggregateExecutor::WindowAggregateExecutor(BoundWindowExpression &wexpr, C // see https://dl.acm.org/doi/pdf/10.1145/3514221.3526184 aggregator = make_uniq(wexpr, shared, context); } else if (WindowConstantAggregator::CanAggregate(wexpr)) { - aggregator = make_uniq(wexpr, shared); + aggregator = make_uniq(wexpr, shared, context); } else if (WindowCustomAggregator::CanAggregate(wexpr, mode)) { aggregator = make_uniq(wexpr, shared); } else if (WindowSegmentTree::CanAggregate(wexpr)) { diff --git a/src/duckdb/src/function/window/window_constant_aggregator.cpp b/src/duckdb/src/function/window/window_constant_aggregator.cpp index 4be038229..0e09c6f99 100644 --- a/src/duckdb/src/function/window/window_constant_aggregator.cpp +++ b/src/duckdb/src/function/window/window_constant_aggregator.cpp @@ -1,4 +1,6 @@ #include "duckdb/function/window/window_constant_aggregator.hpp" + +#include "duckdb/function/function_binder.hpp" #include "duckdb/function/window/window_aggregate_states.hpp" #include "duckdb/function/window/window_shared_expressions.hpp" #include "duckdb/planner/expression/bound_window_expression.hpp" @@ -126,16 +128,10 @@ bool WindowConstantAggregator::CanAggregate(const BoundWindowExpression &wexpr) } // DISTINCT aggregation cannot be handled by constant aggregation - // TODO: Use a hash table if (wexpr.distinct) { return false; } - // ORDER BY arguments cannot be handled by constant aggregation - if (!wexpr.arg_orders.empty()) { - return false; - } - // COUNT(*) is already handled efficiently by segment trees. if (wexpr.children.empty()) { return false; @@ -185,8 +181,15 @@ bool WindowConstantAggregator::CanAggregate(const BoundWindowExpression &wexpr) return true; } -WindowConstantAggregator::WindowConstantAggregator(const BoundWindowExpression &wexpr, WindowSharedExpressions &shared) - : WindowAggregator(wexpr) { +BoundWindowExpression &WindowConstantAggregator::RebindAggregate(ClientContext &context, BoundWindowExpression &wexpr) { + FunctionBinder::BindSortedAggregate(context, wexpr); + + return wexpr; +} + +WindowConstantAggregator::WindowConstantAggregator(BoundWindowExpression &wexpr, WindowSharedExpressions &shared, + ClientContext &context) + : WindowAggregator(RebindAggregate(context, wexpr)) { // We only need these values for Sink for (auto &child : wexpr.children) { diff --git a/src/duckdb/src/function/window/window_executor.cpp b/src/duckdb/src/function/window/window_executor.cpp index f4dab47af..faa7215e4 100644 --- a/src/duckdb/src/function/window/window_executor.cpp +++ b/src/duckdb/src/function/window/window_executor.cpp @@ -41,10 +41,6 @@ WindowExecutor::WindowExecutor(BoundWindowExpression &wexpr, ClientContext &cont boundary_start_idx = shared.RegisterEvaluate(wexpr.start_expr); boundary_end_idx = shared.RegisterEvaluate(wexpr.end_expr); - - for (const auto &order : wexpr.arg_orders) { - arg_order_idx.emplace_back(shared.RegisterSink(order.expression)); - } } void WindowExecutor::Evaluate(idx_t row_idx, DataChunk &eval_chunk, Vector &result, WindowExecutorLocalState &lstate, diff --git a/src/duckdb/src/function/window/window_rank_function.cpp b/src/duckdb/src/function/window/window_rank_function.cpp index b71a4aeac..b128ea89a 100644 --- a/src/duckdb/src/function/window/window_rank_function.cpp +++ b/src/duckdb/src/function/window/window_rank_function.cpp @@ -93,6 +93,10 @@ void WindowPeerLocalState::NextRank(idx_t partition_begin, idx_t peer_begin, idx WindowPeerExecutor::WindowPeerExecutor(BoundWindowExpression &wexpr, ClientContext &context, WindowSharedExpressions &shared) : WindowExecutor(wexpr, context, shared) { + + for (const auto &order : wexpr.arg_orders) { + arg_order_idx.emplace_back(shared.RegisterSink(order.expression)); + } } unique_ptr WindowPeerExecutor::GetGlobalState(const idx_t payload_count, diff --git a/src/duckdb/src/function/window/window_rownumber_function.cpp b/src/duckdb/src/function/window/window_rownumber_function.cpp index 5d766980f..f946583f1 100644 --- a/src/duckdb/src/function/window/window_rownumber_function.cpp +++ b/src/duckdb/src/function/window/window_rownumber_function.cpp @@ -79,6 +79,10 @@ void WindowRowNumberLocalState::Finalize(WindowExecutorGlobalState &gstate, Coll WindowRowNumberExecutor::WindowRowNumberExecutor(BoundWindowExpression &wexpr, ClientContext &context, WindowSharedExpressions &shared) : WindowExecutor(wexpr, context, shared) { + + for (const auto &order : wexpr.arg_orders) { + arg_order_idx.emplace_back(shared.RegisterSink(order.expression)); + } } unique_ptr WindowRowNumberExecutor::GetGlobalState(const idx_t payload_count, diff --git a/src/duckdb/src/function/window/window_value_function.cpp b/src/duckdb/src/function/window/window_value_function.cpp index 7639b3f16..6b8a7038e 100644 --- a/src/duckdb/src/function/window/window_value_function.cpp +++ b/src/duckdb/src/function/window/window_value_function.cpp @@ -136,6 +136,10 @@ WindowValueExecutor::WindowValueExecutor(BoundWindowExpression &wexpr, ClientCon WindowSharedExpressions &shared) : WindowExecutor(wexpr, context, shared) { + for (const auto &order : wexpr.arg_orders) { + arg_order_idx.emplace_back(shared.RegisterSink(order.expression)); + } + // The children have to be handled separately because only the first one is global if (!wexpr.children.empty()) { child_idx = shared.RegisterCollection(wexpr.children[0], wexpr.ignore_nulls); diff --git a/src/duckdb/src/include/duckdb/common/serializer/memory_stream.hpp b/src/duckdb/src/include/duckdb/common/serializer/memory_stream.hpp index f8f539c44..863a99815 100644 --- a/src/duckdb/src/include/duckdb/common/serializer/memory_stream.hpp +++ b/src/duckdb/src/include/duckdb/common/serializer/memory_stream.hpp @@ -33,6 +33,13 @@ class MemoryStream : public WriteStream, public ReadStream { // is destroyed explicit MemoryStream(data_ptr_t buffer, idx_t capacity); + // Cant copy! + MemoryStream(const MemoryStream &) = delete; + MemoryStream &operator=(const MemoryStream &) = delete; + + MemoryStream(MemoryStream &&other) noexcept; + MemoryStream &operator=(MemoryStream &&other) noexcept; + ~MemoryStream() override; // Write data to the stream. diff --git a/src/duckdb/src/include/duckdb/function/function_binder.hpp b/src/duckdb/src/include/duckdb/function/function_binder.hpp index 53e90b2ef..3bec4d379 100644 --- a/src/duckdb/src/include/duckdb/function/function_binder.hpp +++ b/src/duckdb/src/include/duckdb/function/function_binder.hpp @@ -71,6 +71,7 @@ class FunctionBinder { DUCKDB_API static void BindSortedAggregate(ClientContext &context, BoundAggregateExpression &expr, const vector> &groups); + DUCKDB_API static void BindSortedAggregate(ClientContext &context, BoundWindowExpression &expr); private: //! Cast a set of expressions to the arguments of this function diff --git a/src/duckdb/src/include/duckdb/function/window/window_constant_aggregator.hpp b/src/duckdb/src/include/duckdb/function/window/window_constant_aggregator.hpp index fdf07cc7a..c3ca63f36 100644 --- a/src/duckdb/src/include/duckdb/function/window/window_constant_aggregator.hpp +++ b/src/duckdb/src/include/duckdb/function/window/window_constant_aggregator.hpp @@ -16,7 +16,9 @@ class WindowConstantAggregator : public WindowAggregator { public: static bool CanAggregate(const BoundWindowExpression &wexpr); - WindowConstantAggregator(const BoundWindowExpression &wexpr, WindowSharedExpressions &shared); + static BoundWindowExpression &RebindAggregate(ClientContext &context, BoundWindowExpression &wexpr); + + WindowConstantAggregator(BoundWindowExpression &wexpr, WindowSharedExpressions &shared, ClientContext &context); ~WindowConstantAggregator() override { } diff --git a/src/duckdb/src/include/duckdb/function/window/window_executor.hpp b/src/duckdb/src/include/duckdb/function/window/window_executor.hpp index 0c5e63548..44d3a9050 100644 --- a/src/duckdb/src/include/duckdb/function/window/window_executor.hpp +++ b/src/duckdb/src/include/duckdb/function/window/window_executor.hpp @@ -114,9 +114,6 @@ class WindowExecutor { optional_ptr range_expr; column_t range_idx = DConstants::INVALID_INDEX; - //! The column indices of any ORDER BY argument expressions - vector arg_order_idx; - protected: virtual void EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate, DataChunk &eval_chunk, Vector &result, idx_t count, idx_t row_idx) const = 0; diff --git a/src/duckdb/src/include/duckdb/function/window/window_rank_function.hpp b/src/duckdb/src/include/duckdb/function/window/window_rank_function.hpp index 3e53012cc..9afb7e970 100644 --- a/src/duckdb/src/include/duckdb/function/window/window_rank_function.hpp +++ b/src/duckdb/src/include/duckdb/function/window/window_rank_function.hpp @@ -19,6 +19,9 @@ class WindowPeerExecutor : public WindowExecutor { unique_ptr GetGlobalState(const idx_t payload_count, const ValidityMask &partition_mask, const ValidityMask &order_mask) const override; unique_ptr GetLocalState(const WindowExecutorGlobalState &gstate) const override; + + //! The column indices of any ORDER BY argument expressions + vector arg_order_idx; }; class WindowRankExecutor : public WindowPeerExecutor { diff --git a/src/duckdb/src/include/duckdb/function/window/window_rownumber_function.hpp b/src/duckdb/src/include/duckdb/function/window/window_rownumber_function.hpp index 7ee0979c6..be9bf4713 100644 --- a/src/duckdb/src/include/duckdb/function/window/window_rownumber_function.hpp +++ b/src/duckdb/src/include/duckdb/function/window/window_rownumber_function.hpp @@ -22,6 +22,8 @@ class WindowRowNumberExecutor : public WindowExecutor { //! The evaluation index of the NTILE column column_t ntile_idx = DConstants::INVALID_INDEX; + //! The column indices of any ORDER BY argument expressions + vector arg_order_idx; protected: void EvaluateInternal(WindowExecutorGlobalState &gstate, WindowExecutorLocalState &lstate, DataChunk &eval_chunk, 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 eb9ba8c7c..1c734e1f8 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 @@ -32,6 +32,8 @@ class WindowValueExecutor : public WindowExecutor { column_t offset_idx = DConstants::INVALID_INDEX; //! The column index of the default value column column_t default_idx = DConstants::INVALID_INDEX; + //! The column indices of any ORDER BY argument expressions + vector arg_order_idx; }; class WindowLeadLagExecutor : public WindowValueExecutor { diff --git a/src/duckdb/src/include/duckdb/planner/bound_result_modifier.hpp b/src/duckdb/src/include/duckdb/planner/bound_result_modifier.hpp index 6d2b4935f..ab0b64dde 100644 --- a/src/duckdb/src/include/duckdb/planner/bound_result_modifier.hpp +++ b/src/duckdb/src/include/duckdb/planner/bound_result_modifier.hpp @@ -154,6 +154,7 @@ class BoundOrderModifier : public BoundResultModifier { //! Remove unneeded/duplicate order elements. //! Returns true of orders is not empty. + static bool Simplify(vector &orders, const vector> &groups); bool Simplify(const vector> &groups); }; diff --git a/src/duckdb/src/planner/bound_result_modifier.cpp b/src/duckdb/src/planner/bound_result_modifier.cpp index a4cb6ed4f..4f4706076 100644 --- a/src/duckdb/src/planner/bound_result_modifier.cpp +++ b/src/duckdb/src/planner/bound_result_modifier.cpp @@ -93,7 +93,7 @@ bool BoundOrderModifier::Equals(const unique_ptr &left, return BoundOrderModifier::Equals(*left, *right); } -bool BoundOrderModifier::Simplify(const vector> &groups) { +bool BoundOrderModifier::Simplify(vector &orders, const vector> &groups) { // for each ORDER BY - check if it is actually necessary // expressions that are in the groups do not need to be ORDERED BY // `ORDER BY` on a group has no effect, because for each aggregate, the group is unique @@ -113,7 +113,11 @@ bool BoundOrderModifier::Simplify(const vector> &groups) } orders.swap(new_order_nodes); - return orders.empty(); + return orders.empty(); // NOLINT +} + +bool BoundOrderModifier::Simplify(const vector> &groups) { + return Simplify(orders, groups); } BoundLimitNode::BoundLimitNode(LimitNodeType type, idx_t constant_integer, double constant_percentage, From db6ceda1466e85056885e3002289731af58cd2a6 Mon Sep 17 00:00:00 2001 From: DuckDB Labs GitHub Bot Date: Mon, 13 Jan 2025 00:36:48 +0000 Subject: [PATCH 11/16] Update vendored DuckDB sources to 55641c4f --- CMakeLists.txt | 2 +- src/duckdb/src/catalog/catalog.cpp | 18 +- .../src/catalog/catalog_search_path.cpp | 8 +- .../src/catalog/default/default_views.cpp | 1 + .../src/common/arrow/arrow_appender.cpp | 39 +- .../src/common/arrow/arrow_converter.cpp | 145 +++---- .../src/common/arrow/arrow_merge_event.cpp | 5 +- .../src/common/arrow/arrow_type_extension.cpp | 361 ++++++++++++++++++ src/duckdb/src/common/arrow/arrow_util.cpp | 16 +- src/duckdb/src/common/arrow/arrow_wrapper.cpp | 8 +- .../common/arrow/physical_arrow_collector.cpp | 3 +- .../src/common/arrow/schema_metadata.cpp | 33 +- src/duckdb/src/common/enum_util.cpp | 61 +++ src/duckdb/src/common/local_file_system.cpp | 8 + src/duckdb/src/function/function_list.cpp | 1 + .../src/function/scalar/system/write_log.cpp | 170 +++++++++ src/duckdb/src/function/table/arrow.cpp | 352 +---------------- .../table/arrow/arrow_array_scan_state.cpp | 5 +- .../table/arrow/arrow_duck_schema.cpp | 288 +++++++++++++- .../function/table/arrow/arrow_type_info.cpp | 12 +- .../src/function/table/arrow_conversion.cpp | 12 + .../src/function/table/system/duckdb_log.cpp | 64 ++++ .../table/system/duckdb_log_contexts.cpp | 65 ++++ .../src/function/table/system_functions.cpp | 2 + src/duckdb/src/function/table/table_scan.cpp | 51 ++- .../function/table/version/pragma_version.cpp | 6 +- .../src/include/duckdb/catalog/catalog.hpp | 2 +- .../common/arrow/appender/append_data.hpp | 5 +- .../duckdb/common/arrow/arrow_appender.hpp | 10 +- .../duckdb/common/arrow/arrow_converter.hpp | 29 +- .../common/arrow/arrow_query_result.hpp | 2 +- .../common/arrow/arrow_type_extension.hpp | 144 +++++++ .../duckdb/common/arrow/arrow_util.hpp | 7 +- .../common/arrow/result_arrow_wrapper.hpp | 2 + .../duckdb/common/arrow/schema_metadata.hpp | 9 +- .../src/include/duckdb/common/enum_util.hpp | 24 ++ .../src/include/duckdb/common/file_opener.hpp | 2 + .../function/scalar/system_functions.hpp | 9 + .../include/duckdb/function/table/arrow.hpp | 21 +- .../table/arrow/arrow_duck_schema.hpp | 65 +++- .../function/table/arrow/arrow_type_info.hpp | 21 +- .../table/arrow/enum/arrow_type_info_type.hpp | 2 + .../function/table/system_functions.hpp | 8 + .../duckdb/function/table/table_scan.hpp | 4 +- .../include/duckdb/logging/http_logger.hpp | 2 + .../include/duckdb/logging/log_manager.hpp | 81 ++++ .../include/duckdb/logging/log_storage.hpp | 127 ++++++ .../src/include/duckdb/logging/logger.hpp | 287 ++++++++++++++ .../src/include/duckdb/logging/logging.hpp | 83 ++++ .../src/include/duckdb/main/client_config.hpp | 2 +- .../include/duckdb/main/client_context.hpp | 9 +- .../main/client_context_file_opener.hpp | 1 + .../src/include/duckdb/main/client_data.hpp | 3 +- .../include/duckdb/main/client_properties.hpp | 11 +- src/duckdb/src/include/duckdb/main/config.hpp | 13 +- .../src/include/duckdb/main/database.hpp | 9 +- .../duckdb/main/database_file_opener.hpp | 4 + .../src/include/duckdb/main/settings.hpp | 60 +++ .../src/include/duckdb/parallel/event.hpp | 3 + .../duckdb/parallel/thread_context.hpp | 3 + src/duckdb/src/logging/log_manager.cpp | 155 ++++++++ src/duckdb/src/logging/log_storage.cpp | 209 ++++++++++ src/duckdb/src/logging/logger.cpp | 211 ++++++++++ src/duckdb/src/logging/logging.cpp | 42 ++ src/duckdb/src/main/capi/arrow-c.cpp | 13 +- src/duckdb/src/main/capi/helper-c.cpp | 2 + src/duckdb/src/main/client_context.cpp | 37 +- .../src/main/client_context_file_opener.cpp | 4 + src/duckdb/src/main/config.cpp | 6 + src/duckdb/src/main/database.cpp | 17 + src/duckdb/src/main/database_manager.cpp | 3 + .../src/main/extension/extension_helper.cpp | 2 + src/duckdb/src/main/query_result.cpp | 3 +- .../src/main/settings/custom_settings.cpp | 106 +++++ .../src/optimizer/expression_rewriter.cpp | 4 + src/duckdb/src/parallel/event.cpp | 4 + src/duckdb/src/parallel/thread_context.cpp | 13 +- .../src/transaction/meta_transaction.cpp | 5 +- src/duckdb/ub_src_common_arrow.cpp | 4 +- src/duckdb/ub_src_function_scalar_system.cpp | 2 + src/duckdb/ub_src_function_table_system.cpp | 4 + src/duckdb/ub_src_logging.cpp | 8 + 82 files changed, 3077 insertions(+), 577 deletions(-) create mode 100644 src/duckdb/src/common/arrow/arrow_type_extension.cpp create mode 100644 src/duckdb/src/function/scalar/system/write_log.cpp create mode 100644 src/duckdb/src/function/table/system/duckdb_log.cpp create mode 100644 src/duckdb/src/function/table/system/duckdb_log_contexts.cpp create mode 100644 src/duckdb/src/include/duckdb/common/arrow/arrow_type_extension.hpp create mode 100644 src/duckdb/src/include/duckdb/logging/log_manager.hpp create mode 100644 src/duckdb/src/include/duckdb/logging/log_storage.hpp create mode 100644 src/duckdb/src/include/duckdb/logging/logger.hpp create mode 100644 src/duckdb/src/include/duckdb/logging/logging.hpp create mode 100644 src/duckdb/src/logging/log_manager.cpp create mode 100644 src/duckdb/src/logging/log_storage.cpp create mode 100644 src/duckdb/src/logging/logger.cpp create mode 100644 src/duckdb/src/logging/logging.cpp create mode 100644 src/duckdb/ub_src_logging.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index a6cacc0fd..db9f68653 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -25,7 +25,7 @@ add_definitions(-DDUCKDB_EXTENSION_AUTOLOAD_DEFAULT=1 -DDUCKDB_EXTENSION_AUTOINS file(GLOB_RECURSE JAVA_SRC_FILES src/main/java/org/duckdb/*.java) file(GLOB_RECURSE JAVA_TEST_FILES src/test/java/org/duckdb/*.java) -set(DUCKDB_SRC_FILES src/duckdb/ub_src_catalog.cpp src/duckdb/ub_src_catalog_catalog_entry.cpp src/duckdb/ub_src_catalog_catalog_entry_dependency.cpp src/duckdb/ub_src_catalog_default.cpp src/duckdb/ub_src_common_adbc.cpp src/duckdb/ub_src_common_adbc_nanoarrow.cpp src/duckdb/ub_src_common.cpp src/duckdb/ub_src_common_arrow_appender.cpp src/duckdb/ub_src_common_arrow.cpp src/duckdb/ub_src_common_crypto.cpp src/duckdb/ub_src_common_enums.cpp src/duckdb/ub_src_common_exception.cpp src/duckdb/ub_src_common_operator.cpp src/duckdb/ub_src_common_progress_bar.cpp src/duckdb/ub_src_common_row_operations.cpp src/duckdb/ub_src_common_serializer.cpp src/duckdb/ub_src_common_sort.cpp src/duckdb/ub_src_common_tree_renderer.cpp src/duckdb/ub_src_common_types.cpp src/duckdb/ub_src_common_types_column.cpp src/duckdb/ub_src_common_types_row.cpp src/duckdb/ub_src_common_value_operations.cpp src/duckdb/src/common/vector_operations/boolean_operators.cpp src/duckdb/src/common/vector_operations/comparison_operators.cpp src/duckdb/src/common/vector_operations/generators.cpp src/duckdb/src/common/vector_operations/is_distinct_from.cpp src/duckdb/src/common/vector_operations/null_operations.cpp src/duckdb/src/common/vector_operations/numeric_inplace_operators.cpp src/duckdb/src/common/vector_operations/vector_cast.cpp src/duckdb/src/common/vector_operations/vector_copy.cpp src/duckdb/src/common/vector_operations/vector_hash.cpp src/duckdb/src/common/vector_operations/vector_storage.cpp src/duckdb/ub_src_execution.cpp src/duckdb/ub_src_execution_expression_executor.cpp src/duckdb/ub_src_execution_index_art.cpp src/duckdb/ub_src_execution_index.cpp src/duckdb/ub_src_execution_nested_loop_join.cpp src/duckdb/ub_src_execution_operator_aggregate.cpp src/duckdb/ub_src_execution_operator_csv_scanner_buffer_manager.cpp src/duckdb/ub_src_execution_operator_csv_scanner_encode.cpp src/duckdb/ub_src_execution_operator_csv_scanner_scanner.cpp src/duckdb/ub_src_execution_operator_csv_scanner_sniffer.cpp src/duckdb/ub_src_execution_operator_csv_scanner_state_machine.cpp src/duckdb/ub_src_execution_operator_csv_scanner_table_function.cpp src/duckdb/ub_src_execution_operator_csv_scanner_util.cpp src/duckdb/ub_src_execution_operator_filter.cpp src/duckdb/ub_src_execution_operator_helper.cpp src/duckdb/ub_src_execution_operator_join.cpp src/duckdb/ub_src_execution_operator_order.cpp src/duckdb/ub_src_execution_operator_persistent.cpp src/duckdb/ub_src_execution_operator_projection.cpp src/duckdb/ub_src_execution_operator_scan.cpp src/duckdb/ub_src_execution_operator_schema.cpp src/duckdb/ub_src_execution_operator_set.cpp src/duckdb/ub_src_execution_physical_plan.cpp src/duckdb/ub_src_execution_sample.cpp src/duckdb/ub_src_function_aggregate_distributive.cpp src/duckdb/ub_src_function_aggregate.cpp src/duckdb/ub_src_function.cpp src/duckdb/ub_src_function_cast.cpp src/duckdb/ub_src_function_cast_union.cpp src/duckdb/ub_src_function_pragma.cpp src/duckdb/ub_src_function_scalar_compressed_materialization.cpp src/duckdb/ub_src_function_scalar.cpp src/duckdb/ub_src_function_scalar_date.cpp src/duckdb/ub_src_function_scalar_generic.cpp src/duckdb/ub_src_function_scalar_list.cpp src/duckdb/ub_src_function_scalar_map.cpp src/duckdb/ub_src_function_scalar_operator.cpp src/duckdb/ub_src_function_scalar_sequence.cpp src/duckdb/ub_src_function_scalar_string.cpp src/duckdb/ub_src_function_scalar_string_regexp.cpp src/duckdb/ub_src_function_scalar_struct.cpp src/duckdb/ub_src_function_scalar_system.cpp src/duckdb/ub_src_function_table_arrow.cpp src/duckdb/ub_src_function_table.cpp src/duckdb/ub_src_function_table_system.cpp src/duckdb/ub_src_function_table_version.cpp src/duckdb/ub_src_function_window.cpp src/duckdb/ub_src_main.cpp src/duckdb/ub_src_main_buffered_data.cpp src/duckdb/ub_src_main_capi.cpp src/duckdb/ub_src_main_capi_cast.cpp src/duckdb/ub_src_main_chunk_scan_state.cpp src/duckdb/ub_src_main_extension.cpp src/duckdb/ub_src_main_relation.cpp src/duckdb/ub_src_main_secret.cpp src/duckdb/ub_src_main_settings.cpp src/duckdb/ub_src_optimizer.cpp src/duckdb/ub_src_optimizer_compressed_materialization.cpp src/duckdb/ub_src_optimizer_join_order.cpp src/duckdb/ub_src_optimizer_matcher.cpp src/duckdb/ub_src_optimizer_pullup.cpp src/duckdb/ub_src_optimizer_pushdown.cpp src/duckdb/ub_src_optimizer_rule.cpp src/duckdb/ub_src_optimizer_statistics_expression.cpp src/duckdb/ub_src_optimizer_statistics_operator.cpp src/duckdb/ub_src_parallel.cpp src/duckdb/ub_src_parser.cpp src/duckdb/ub_src_parser_constraints.cpp src/duckdb/ub_src_parser_expression.cpp src/duckdb/ub_src_parser_parsed_data.cpp src/duckdb/ub_src_parser_query_node.cpp src/duckdb/ub_src_parser_statement.cpp src/duckdb/ub_src_parser_tableref.cpp src/duckdb/ub_src_parser_transform_constraint.cpp src/duckdb/ub_src_parser_transform_expression.cpp src/duckdb/ub_src_parser_transform_helpers.cpp src/duckdb/ub_src_parser_transform_statement.cpp src/duckdb/ub_src_parser_transform_tableref.cpp src/duckdb/ub_src_planner.cpp src/duckdb/ub_src_planner_binder_expression.cpp src/duckdb/ub_src_planner_binder_query_node.cpp src/duckdb/ub_src_planner_binder_statement.cpp src/duckdb/ub_src_planner_binder_tableref.cpp src/duckdb/ub_src_planner_expression.cpp src/duckdb/ub_src_planner_expression_binder.cpp src/duckdb/ub_src_planner_filter.cpp src/duckdb/ub_src_planner_operator.cpp src/duckdb/ub_src_planner_subquery.cpp src/duckdb/ub_src_storage.cpp src/duckdb/ub_src_storage_buffer.cpp src/duckdb/ub_src_storage_checkpoint.cpp src/duckdb/ub_src_storage_compression_alp.cpp src/duckdb/ub_src_storage_compression.cpp src/duckdb/ub_src_storage_compression_chimp.cpp src/duckdb/ub_src_storage_compression_dictionary.cpp src/duckdb/ub_src_storage_compression_roaring.cpp src/duckdb/ub_src_storage_metadata.cpp src/duckdb/ub_src_storage_serialization.cpp src/duckdb/ub_src_storage_statistics.cpp src/duckdb/ub_src_storage_table.cpp src/duckdb/ub_src_transaction.cpp src/duckdb/src/verification/copied_statement_verifier.cpp src/duckdb/src/verification/deserialized_statement_verifier.cpp src/duckdb/src/verification/external_statement_verifier.cpp src/duckdb/src/verification/fetch_row_verifier.cpp src/duckdb/src/verification/no_operator_caching_verifier.cpp src/duckdb/src/verification/parsed_statement_verifier.cpp src/duckdb/src/verification/prepared_statement_verifier.cpp src/duckdb/src/verification/statement_verifier.cpp src/duckdb/src/verification/unoptimized_statement_verifier.cpp src/duckdb/third_party/fmt/format.cc src/duckdb/third_party/fsst/libfsst.cpp src/duckdb/third_party/miniz/miniz.cpp src/duckdb/third_party/re2/re2/bitmap256.cc src/duckdb/third_party/re2/re2/bitstate.cc src/duckdb/third_party/re2/re2/compile.cc src/duckdb/third_party/re2/re2/dfa.cc src/duckdb/third_party/re2/re2/filtered_re2.cc src/duckdb/third_party/re2/re2/mimics_pcre.cc src/duckdb/third_party/re2/re2/nfa.cc src/duckdb/third_party/re2/re2/onepass.cc src/duckdb/third_party/re2/re2/parse.cc src/duckdb/third_party/re2/re2/perl_groups.cc src/duckdb/third_party/re2/re2/prefilter.cc src/duckdb/third_party/re2/re2/prefilter_tree.cc src/duckdb/third_party/re2/re2/prog.cc src/duckdb/third_party/re2/re2/re2.cc src/duckdb/third_party/re2/re2/regexp.cc src/duckdb/third_party/re2/re2/set.cc src/duckdb/third_party/re2/re2/simplify.cc src/duckdb/third_party/re2/re2/stringpiece.cc src/duckdb/third_party/re2/re2/tostring.cc src/duckdb/third_party/re2/re2/unicode_casefold.cc src/duckdb/third_party/re2/re2/unicode_groups.cc src/duckdb/third_party/re2/util/rune.cc src/duckdb/third_party/re2/util/strutil.cc src/duckdb/third_party/hyperloglog/hyperloglog.cpp src/duckdb/third_party/hyperloglog/sds.cpp src/duckdb/third_party/skiplist/SkipList.cpp src/duckdb/third_party/fastpforlib/bitpacking.cpp src/duckdb/third_party/utf8proc/utf8proc.cpp src/duckdb/third_party/utf8proc/utf8proc_wrapper.cpp src/duckdb/third_party/libpg_query/pg_functions.cpp src/duckdb/third_party/libpg_query/postgres_parser.cpp src/duckdb/third_party/libpg_query/src_backend_nodes_list.cpp src/duckdb/third_party/libpg_query/src_backend_nodes_makefuncs.cpp src/duckdb/third_party/libpg_query/src_backend_nodes_value.cpp src/duckdb/third_party/libpg_query/src_backend_parser_gram.cpp src/duckdb/third_party/libpg_query/src_backend_parser_parser.cpp src/duckdb/third_party/libpg_query/src_backend_parser_scan.cpp src/duckdb/third_party/libpg_query/src_backend_parser_scansup.cpp src/duckdb/third_party/libpg_query/src_common_keywords.cpp src/duckdb/third_party/mbedtls/library/aes.cpp src/duckdb/third_party/mbedtls/library/aria.cpp src/duckdb/third_party/mbedtls/library/asn1parse.cpp src/duckdb/third_party/mbedtls/library/base64.cpp src/duckdb/third_party/mbedtls/library/bignum.cpp src/duckdb/third_party/mbedtls/library/camellia.cpp src/duckdb/third_party/mbedtls/library/cipher.cpp src/duckdb/third_party/mbedtls/library/cipher_wrap.cpp src/duckdb/third_party/mbedtls/library/constant_time.cpp src/duckdb/third_party/mbedtls/library/entropy.cpp src/duckdb/third_party/mbedtls/library/entropy_poll.cpp src/duckdb/third_party/mbedtls/library/gcm.cpp src/duckdb/third_party/mbedtls/library/md.cpp src/duckdb/third_party/mbedtls/library/oid.cpp src/duckdb/third_party/mbedtls/library/pem.cpp src/duckdb/third_party/mbedtls/library/pk.cpp src/duckdb/third_party/mbedtls/library/pk_wrap.cpp src/duckdb/third_party/mbedtls/library/pkparse.cpp src/duckdb/third_party/mbedtls/library/platform_util.cpp src/duckdb/third_party/mbedtls/library/rsa.cpp src/duckdb/third_party/mbedtls/library/rsa_alt_helpers.cpp src/duckdb/third_party/mbedtls/library/sha1.cpp src/duckdb/third_party/mbedtls/library/sha256.cpp src/duckdb/third_party/mbedtls/library/sha512.cpp src/duckdb/third_party/mbedtls/mbedtls_wrapper.cpp src/duckdb/third_party/yyjson/yyjson.cpp src/duckdb/third_party/zstd/common/debug.cpp src/duckdb/third_party/zstd/common/entropy_common.cpp src/duckdb/third_party/zstd/common/error_private.cpp src/duckdb/third_party/zstd/common/fse_decompress.cpp src/duckdb/third_party/zstd/common/pool.cpp src/duckdb/third_party/zstd/common/threading.cpp src/duckdb/third_party/zstd/common/xxhash.cpp src/duckdb/third_party/zstd/common/zstd_common.cpp src/duckdb/third_party/zstd/compress/fse_compress.cpp src/duckdb/third_party/zstd/compress/hist.cpp src/duckdb/third_party/zstd/compress/huf_compress.cpp src/duckdb/third_party/zstd/compress/zstd_compress.cpp src/duckdb/third_party/zstd/compress/zstd_compress_literals.cpp src/duckdb/third_party/zstd/compress/zstd_compress_sequences.cpp src/duckdb/third_party/zstd/compress/zstd_compress_superblock.cpp src/duckdb/third_party/zstd/compress/zstd_double_fast.cpp src/duckdb/third_party/zstd/compress/zstd_fast.cpp src/duckdb/third_party/zstd/compress/zstd_lazy.cpp src/duckdb/third_party/zstd/compress/zstd_ldm.cpp src/duckdb/third_party/zstd/compress/zstd_opt.cpp src/duckdb/third_party/zstd/compress/zstdmt_compress.cpp src/duckdb/third_party/zstd/decompress/huf_decompress.cpp src/duckdb/third_party/zstd/decompress/zstd_ddict.cpp src/duckdb/third_party/zstd/decompress/zstd_decompress.cpp src/duckdb/third_party/zstd/decompress/zstd_decompress_block.cpp src/duckdb/third_party/zstd/deprecated/zbuff_common.cpp src/duckdb/third_party/zstd/deprecated/zbuff_compress.cpp src/duckdb/third_party/zstd/deprecated/zbuff_decompress.cpp src/duckdb/third_party/zstd/dict/cover.cpp src/duckdb/third_party/zstd/dict/divsufsort.cpp src/duckdb/third_party/zstd/dict/fastcover.cpp src/duckdb/third_party/zstd/dict/zdict.cpp src/duckdb/extension/core_functions/core_functions_extension.cpp src/duckdb/extension/core_functions/lambda_functions.cpp src/duckdb/extension/core_functions/function_list.cpp src/duckdb/ub_extension_core_functions_aggregate_regression.cpp src/duckdb/ub_extension_core_functions_aggregate_algebraic.cpp src/duckdb/ub_extension_core_functions_aggregate_nested.cpp src/duckdb/ub_extension_core_functions_aggregate_holistic.cpp src/duckdb/ub_extension_core_functions_aggregate_distributive.cpp src/duckdb/ub_extension_core_functions_scalar_random.cpp src/duckdb/ub_extension_core_functions_scalar_string.cpp src/duckdb/ub_extension_core_functions_scalar_math.cpp src/duckdb/ub_extension_core_functions_scalar_generic.cpp src/duckdb/ub_extension_core_functions_scalar_enum.cpp src/duckdb/ub_extension_core_functions_scalar_map.cpp src/duckdb/ub_extension_core_functions_scalar_operators.cpp src/duckdb/ub_extension_core_functions_scalar_date.cpp src/duckdb/ub_extension_core_functions_scalar_list.cpp src/duckdb/ub_extension_core_functions_scalar_blob.cpp src/duckdb/ub_extension_core_functions_scalar_debug.cpp src/duckdb/ub_extension_core_functions_scalar_array.cpp src/duckdb/ub_extension_core_functions_scalar_union.cpp src/duckdb/ub_extension_core_functions_scalar_struct.cpp src/duckdb/ub_extension_core_functions_scalar_bit.cpp src/duckdb/extension/parquet/column_reader.cpp src/duckdb/extension/parquet/column_writer.cpp src/duckdb/extension/parquet/parquet_crypto.cpp src/duckdb/extension/parquet/parquet_extension.cpp src/duckdb/extension/parquet/parquet_metadata.cpp src/duckdb/extension/parquet/parquet_reader.cpp src/duckdb/extension/parquet/parquet_statistics.cpp src/duckdb/extension/parquet/parquet_timestamp.cpp src/duckdb/extension/parquet/parquet_writer.cpp src/duckdb/extension/parquet/serialize_parquet.cpp src/duckdb/extension/parquet/zstd_file_system.cpp src/duckdb/extension/parquet/geo_parquet.cpp src/duckdb/third_party/parquet/parquet_types.cpp src/duckdb/third_party/thrift/thrift/protocol/TProtocol.cpp src/duckdb/third_party/thrift/thrift/transport/TTransportException.cpp src/duckdb/third_party/thrift/thrift/transport/TBufferTransports.cpp src/duckdb/third_party/snappy/snappy.cc src/duckdb/third_party/snappy/snappy-sinksource.cc src/duckdb/third_party/lz4/lz4.cpp src/duckdb/third_party/brotli/common/constants.cpp src/duckdb/third_party/brotli/common/context.cpp src/duckdb/third_party/brotli/common/dictionary.cpp src/duckdb/third_party/brotli/common/platform.cpp src/duckdb/third_party/brotli/common/shared_dictionary.cpp src/duckdb/third_party/brotli/common/transform.cpp src/duckdb/third_party/brotli/dec/bit_reader.cpp src/duckdb/third_party/brotli/dec/decode.cpp src/duckdb/third_party/brotli/dec/huffman.cpp src/duckdb/third_party/brotli/dec/state.cpp src/duckdb/third_party/brotli/enc/backward_references.cpp src/duckdb/third_party/brotli/enc/backward_references_hq.cpp src/duckdb/third_party/brotli/enc/bit_cost.cpp src/duckdb/third_party/brotli/enc/block_splitter.cpp src/duckdb/third_party/brotli/enc/brotli_bit_stream.cpp src/duckdb/third_party/brotli/enc/cluster.cpp src/duckdb/third_party/brotli/enc/command.cpp src/duckdb/third_party/brotli/enc/compound_dictionary.cpp src/duckdb/third_party/brotli/enc/compress_fragment.cpp src/duckdb/third_party/brotli/enc/compress_fragment_two_pass.cpp src/duckdb/third_party/brotli/enc/dictionary_hash.cpp src/duckdb/third_party/brotli/enc/encode.cpp src/duckdb/third_party/brotli/enc/encoder_dict.cpp src/duckdb/third_party/brotli/enc/entropy_encode.cpp src/duckdb/third_party/brotli/enc/fast_log.cpp src/duckdb/third_party/brotli/enc/histogram.cpp src/duckdb/third_party/brotli/enc/literal_cost.cpp src/duckdb/third_party/brotli/enc/memory.cpp src/duckdb/third_party/brotli/enc/metablock.cpp src/duckdb/third_party/brotli/enc/static_dict.cpp src/duckdb/third_party/brotli/enc/utf8_util.cpp src/duckdb/extension/icu/./icu-table-range.cpp src/duckdb/extension/icu/./icu-datefunc.cpp src/duckdb/extension/icu/./icu-datepart.cpp src/duckdb/extension/icu/./icu-datetrunc.cpp src/duckdb/extension/icu/./icu_extension.cpp src/duckdb/extension/icu/./icu-timezone.cpp src/duckdb/extension/icu/./icu-timebucket.cpp src/duckdb/extension/icu/./icu-makedate.cpp src/duckdb/extension/icu/./icu-datesub.cpp src/duckdb/extension/icu/./icu-dateadd.cpp src/duckdb/extension/icu/./icu-list-range.cpp src/duckdb/extension/icu/./icu-strptime.cpp src/duckdb/ub_extension_icu_third_party_icu_common.cpp src/duckdb/ub_extension_icu_third_party_icu_i18n.cpp src/duckdb/extension/icu/third_party/icu/stubdata/stubdata.cpp src/duckdb/extension/json/buffered_json_reader.cpp src/duckdb/extension/json/json_enums.cpp src/duckdb/extension/json/json_extension.cpp src/duckdb/extension/json/json_common.cpp src/duckdb/extension/json/json_functions.cpp src/duckdb/extension/json/json_scan.cpp src/duckdb/extension/json/json_serializer.cpp src/duckdb/extension/json/json_deserializer.cpp src/duckdb/extension/json/serialize_json.cpp src/duckdb/ub_extension_json_json_functions.cpp) +set(DUCKDB_SRC_FILES src/duckdb/ub_src_catalog.cpp src/duckdb/ub_src_catalog_catalog_entry.cpp src/duckdb/ub_src_catalog_catalog_entry_dependency.cpp src/duckdb/ub_src_catalog_default.cpp src/duckdb/ub_src_common_adbc.cpp src/duckdb/ub_src_common_adbc_nanoarrow.cpp src/duckdb/ub_src_common.cpp src/duckdb/ub_src_common_arrow_appender.cpp src/duckdb/ub_src_common_arrow.cpp src/duckdb/ub_src_common_crypto.cpp src/duckdb/ub_src_common_enums.cpp src/duckdb/ub_src_common_exception.cpp src/duckdb/ub_src_common_operator.cpp src/duckdb/ub_src_common_progress_bar.cpp src/duckdb/ub_src_common_row_operations.cpp src/duckdb/ub_src_common_serializer.cpp src/duckdb/ub_src_common_sort.cpp src/duckdb/ub_src_common_tree_renderer.cpp src/duckdb/ub_src_common_types.cpp src/duckdb/ub_src_common_types_column.cpp src/duckdb/ub_src_common_types_row.cpp src/duckdb/ub_src_common_value_operations.cpp src/duckdb/src/common/vector_operations/boolean_operators.cpp src/duckdb/src/common/vector_operations/comparison_operators.cpp src/duckdb/src/common/vector_operations/generators.cpp src/duckdb/src/common/vector_operations/is_distinct_from.cpp src/duckdb/src/common/vector_operations/null_operations.cpp src/duckdb/src/common/vector_operations/numeric_inplace_operators.cpp src/duckdb/src/common/vector_operations/vector_cast.cpp src/duckdb/src/common/vector_operations/vector_copy.cpp src/duckdb/src/common/vector_operations/vector_hash.cpp src/duckdb/src/common/vector_operations/vector_storage.cpp src/duckdb/ub_src_execution.cpp src/duckdb/ub_src_execution_expression_executor.cpp src/duckdb/ub_src_execution_index_art.cpp src/duckdb/ub_src_execution_index.cpp src/duckdb/ub_src_execution_nested_loop_join.cpp src/duckdb/ub_src_execution_operator_aggregate.cpp src/duckdb/ub_src_execution_operator_csv_scanner_buffer_manager.cpp src/duckdb/ub_src_execution_operator_csv_scanner_encode.cpp src/duckdb/ub_src_execution_operator_csv_scanner_scanner.cpp src/duckdb/ub_src_execution_operator_csv_scanner_sniffer.cpp src/duckdb/ub_src_execution_operator_csv_scanner_state_machine.cpp src/duckdb/ub_src_execution_operator_csv_scanner_table_function.cpp src/duckdb/ub_src_execution_operator_csv_scanner_util.cpp src/duckdb/ub_src_execution_operator_filter.cpp src/duckdb/ub_src_execution_operator_helper.cpp src/duckdb/ub_src_execution_operator_join.cpp src/duckdb/ub_src_execution_operator_order.cpp src/duckdb/ub_src_execution_operator_persistent.cpp src/duckdb/ub_src_execution_operator_projection.cpp src/duckdb/ub_src_execution_operator_scan.cpp src/duckdb/ub_src_execution_operator_schema.cpp src/duckdb/ub_src_execution_operator_set.cpp src/duckdb/ub_src_execution_physical_plan.cpp src/duckdb/ub_src_execution_sample.cpp src/duckdb/ub_src_function_aggregate_distributive.cpp src/duckdb/ub_src_function_aggregate.cpp src/duckdb/ub_src_function.cpp src/duckdb/ub_src_function_cast.cpp src/duckdb/ub_src_function_cast_union.cpp src/duckdb/ub_src_function_pragma.cpp src/duckdb/ub_src_function_scalar_compressed_materialization.cpp src/duckdb/ub_src_function_scalar.cpp src/duckdb/ub_src_function_scalar_date.cpp src/duckdb/ub_src_function_scalar_generic.cpp src/duckdb/ub_src_function_scalar_list.cpp src/duckdb/ub_src_function_scalar_map.cpp src/duckdb/ub_src_function_scalar_operator.cpp src/duckdb/ub_src_function_scalar_sequence.cpp src/duckdb/ub_src_function_scalar_string.cpp src/duckdb/ub_src_function_scalar_string_regexp.cpp src/duckdb/ub_src_function_scalar_struct.cpp src/duckdb/ub_src_function_scalar_system.cpp src/duckdb/ub_src_function_table_arrow.cpp src/duckdb/ub_src_function_table.cpp src/duckdb/ub_src_function_table_system.cpp src/duckdb/ub_src_function_table_version.cpp src/duckdb/ub_src_function_window.cpp src/duckdb/ub_src_logging.cpp src/duckdb/ub_src_main.cpp src/duckdb/ub_src_main_buffered_data.cpp src/duckdb/ub_src_main_capi.cpp src/duckdb/ub_src_main_capi_cast.cpp src/duckdb/ub_src_main_chunk_scan_state.cpp src/duckdb/ub_src_main_extension.cpp src/duckdb/ub_src_main_relation.cpp src/duckdb/ub_src_main_secret.cpp src/duckdb/ub_src_main_settings.cpp src/duckdb/ub_src_optimizer.cpp src/duckdb/ub_src_optimizer_compressed_materialization.cpp src/duckdb/ub_src_optimizer_join_order.cpp src/duckdb/ub_src_optimizer_matcher.cpp src/duckdb/ub_src_optimizer_pullup.cpp src/duckdb/ub_src_optimizer_pushdown.cpp src/duckdb/ub_src_optimizer_rule.cpp src/duckdb/ub_src_optimizer_statistics_expression.cpp src/duckdb/ub_src_optimizer_statistics_operator.cpp src/duckdb/ub_src_parallel.cpp src/duckdb/ub_src_parser.cpp src/duckdb/ub_src_parser_constraints.cpp src/duckdb/ub_src_parser_expression.cpp src/duckdb/ub_src_parser_parsed_data.cpp src/duckdb/ub_src_parser_query_node.cpp src/duckdb/ub_src_parser_statement.cpp src/duckdb/ub_src_parser_tableref.cpp src/duckdb/ub_src_parser_transform_constraint.cpp src/duckdb/ub_src_parser_transform_expression.cpp src/duckdb/ub_src_parser_transform_helpers.cpp src/duckdb/ub_src_parser_transform_statement.cpp src/duckdb/ub_src_parser_transform_tableref.cpp src/duckdb/ub_src_planner.cpp src/duckdb/ub_src_planner_binder_expression.cpp src/duckdb/ub_src_planner_binder_query_node.cpp src/duckdb/ub_src_planner_binder_statement.cpp src/duckdb/ub_src_planner_binder_tableref.cpp src/duckdb/ub_src_planner_expression.cpp src/duckdb/ub_src_planner_expression_binder.cpp src/duckdb/ub_src_planner_filter.cpp src/duckdb/ub_src_planner_operator.cpp src/duckdb/ub_src_planner_subquery.cpp src/duckdb/ub_src_storage.cpp src/duckdb/ub_src_storage_buffer.cpp src/duckdb/ub_src_storage_checkpoint.cpp src/duckdb/ub_src_storage_compression_alp.cpp src/duckdb/ub_src_storage_compression.cpp src/duckdb/ub_src_storage_compression_chimp.cpp src/duckdb/ub_src_storage_compression_dictionary.cpp src/duckdb/ub_src_storage_compression_roaring.cpp src/duckdb/ub_src_storage_metadata.cpp src/duckdb/ub_src_storage_serialization.cpp src/duckdb/ub_src_storage_statistics.cpp src/duckdb/ub_src_storage_table.cpp src/duckdb/ub_src_transaction.cpp src/duckdb/src/verification/copied_statement_verifier.cpp src/duckdb/src/verification/deserialized_statement_verifier.cpp src/duckdb/src/verification/external_statement_verifier.cpp src/duckdb/src/verification/fetch_row_verifier.cpp src/duckdb/src/verification/no_operator_caching_verifier.cpp src/duckdb/src/verification/parsed_statement_verifier.cpp src/duckdb/src/verification/prepared_statement_verifier.cpp src/duckdb/src/verification/statement_verifier.cpp src/duckdb/src/verification/unoptimized_statement_verifier.cpp src/duckdb/third_party/fmt/format.cc src/duckdb/third_party/fsst/libfsst.cpp src/duckdb/third_party/miniz/miniz.cpp src/duckdb/third_party/re2/re2/bitmap256.cc src/duckdb/third_party/re2/re2/bitstate.cc src/duckdb/third_party/re2/re2/compile.cc src/duckdb/third_party/re2/re2/dfa.cc src/duckdb/third_party/re2/re2/filtered_re2.cc src/duckdb/third_party/re2/re2/mimics_pcre.cc src/duckdb/third_party/re2/re2/nfa.cc src/duckdb/third_party/re2/re2/onepass.cc src/duckdb/third_party/re2/re2/parse.cc src/duckdb/third_party/re2/re2/perl_groups.cc src/duckdb/third_party/re2/re2/prefilter.cc src/duckdb/third_party/re2/re2/prefilter_tree.cc src/duckdb/third_party/re2/re2/prog.cc src/duckdb/third_party/re2/re2/re2.cc src/duckdb/third_party/re2/re2/regexp.cc src/duckdb/third_party/re2/re2/set.cc src/duckdb/third_party/re2/re2/simplify.cc src/duckdb/third_party/re2/re2/stringpiece.cc src/duckdb/third_party/re2/re2/tostring.cc src/duckdb/third_party/re2/re2/unicode_casefold.cc src/duckdb/third_party/re2/re2/unicode_groups.cc src/duckdb/third_party/re2/util/rune.cc src/duckdb/third_party/re2/util/strutil.cc src/duckdb/third_party/hyperloglog/hyperloglog.cpp src/duckdb/third_party/hyperloglog/sds.cpp src/duckdb/third_party/skiplist/SkipList.cpp src/duckdb/third_party/fastpforlib/bitpacking.cpp src/duckdb/third_party/utf8proc/utf8proc.cpp src/duckdb/third_party/utf8proc/utf8proc_wrapper.cpp src/duckdb/third_party/libpg_query/pg_functions.cpp src/duckdb/third_party/libpg_query/postgres_parser.cpp src/duckdb/third_party/libpg_query/src_backend_nodes_list.cpp src/duckdb/third_party/libpg_query/src_backend_nodes_makefuncs.cpp src/duckdb/third_party/libpg_query/src_backend_nodes_value.cpp src/duckdb/third_party/libpg_query/src_backend_parser_gram.cpp src/duckdb/third_party/libpg_query/src_backend_parser_parser.cpp src/duckdb/third_party/libpg_query/src_backend_parser_scan.cpp src/duckdb/third_party/libpg_query/src_backend_parser_scansup.cpp src/duckdb/third_party/libpg_query/src_common_keywords.cpp src/duckdb/third_party/mbedtls/library/aes.cpp src/duckdb/third_party/mbedtls/library/aria.cpp src/duckdb/third_party/mbedtls/library/asn1parse.cpp src/duckdb/third_party/mbedtls/library/base64.cpp src/duckdb/third_party/mbedtls/library/bignum.cpp src/duckdb/third_party/mbedtls/library/camellia.cpp src/duckdb/third_party/mbedtls/library/cipher.cpp src/duckdb/third_party/mbedtls/library/cipher_wrap.cpp src/duckdb/third_party/mbedtls/library/constant_time.cpp src/duckdb/third_party/mbedtls/library/entropy.cpp src/duckdb/third_party/mbedtls/library/entropy_poll.cpp src/duckdb/third_party/mbedtls/library/gcm.cpp src/duckdb/third_party/mbedtls/library/md.cpp src/duckdb/third_party/mbedtls/library/oid.cpp src/duckdb/third_party/mbedtls/library/pem.cpp src/duckdb/third_party/mbedtls/library/pk.cpp src/duckdb/third_party/mbedtls/library/pk_wrap.cpp src/duckdb/third_party/mbedtls/library/pkparse.cpp src/duckdb/third_party/mbedtls/library/platform_util.cpp src/duckdb/third_party/mbedtls/library/rsa.cpp src/duckdb/third_party/mbedtls/library/rsa_alt_helpers.cpp src/duckdb/third_party/mbedtls/library/sha1.cpp src/duckdb/third_party/mbedtls/library/sha256.cpp src/duckdb/third_party/mbedtls/library/sha512.cpp src/duckdb/third_party/mbedtls/mbedtls_wrapper.cpp src/duckdb/third_party/yyjson/yyjson.cpp src/duckdb/third_party/zstd/common/debug.cpp src/duckdb/third_party/zstd/common/entropy_common.cpp src/duckdb/third_party/zstd/common/error_private.cpp src/duckdb/third_party/zstd/common/fse_decompress.cpp src/duckdb/third_party/zstd/common/pool.cpp src/duckdb/third_party/zstd/common/threading.cpp src/duckdb/third_party/zstd/common/xxhash.cpp src/duckdb/third_party/zstd/common/zstd_common.cpp src/duckdb/third_party/zstd/compress/fse_compress.cpp src/duckdb/third_party/zstd/compress/hist.cpp src/duckdb/third_party/zstd/compress/huf_compress.cpp src/duckdb/third_party/zstd/compress/zstd_compress.cpp src/duckdb/third_party/zstd/compress/zstd_compress_literals.cpp src/duckdb/third_party/zstd/compress/zstd_compress_sequences.cpp src/duckdb/third_party/zstd/compress/zstd_compress_superblock.cpp src/duckdb/third_party/zstd/compress/zstd_double_fast.cpp src/duckdb/third_party/zstd/compress/zstd_fast.cpp src/duckdb/third_party/zstd/compress/zstd_lazy.cpp src/duckdb/third_party/zstd/compress/zstd_ldm.cpp src/duckdb/third_party/zstd/compress/zstd_opt.cpp src/duckdb/third_party/zstd/compress/zstdmt_compress.cpp src/duckdb/third_party/zstd/decompress/huf_decompress.cpp src/duckdb/third_party/zstd/decompress/zstd_ddict.cpp src/duckdb/third_party/zstd/decompress/zstd_decompress.cpp src/duckdb/third_party/zstd/decompress/zstd_decompress_block.cpp src/duckdb/third_party/zstd/deprecated/zbuff_common.cpp src/duckdb/third_party/zstd/deprecated/zbuff_compress.cpp src/duckdb/third_party/zstd/deprecated/zbuff_decompress.cpp src/duckdb/third_party/zstd/dict/cover.cpp src/duckdb/third_party/zstd/dict/divsufsort.cpp src/duckdb/third_party/zstd/dict/fastcover.cpp src/duckdb/third_party/zstd/dict/zdict.cpp src/duckdb/extension/core_functions/core_functions_extension.cpp src/duckdb/extension/core_functions/lambda_functions.cpp src/duckdb/extension/core_functions/function_list.cpp src/duckdb/ub_extension_core_functions_aggregate_regression.cpp src/duckdb/ub_extension_core_functions_aggregate_algebraic.cpp src/duckdb/ub_extension_core_functions_aggregate_nested.cpp src/duckdb/ub_extension_core_functions_aggregate_holistic.cpp src/duckdb/ub_extension_core_functions_aggregate_distributive.cpp src/duckdb/ub_extension_core_functions_scalar_random.cpp src/duckdb/ub_extension_core_functions_scalar_string.cpp src/duckdb/ub_extension_core_functions_scalar_math.cpp src/duckdb/ub_extension_core_functions_scalar_generic.cpp src/duckdb/ub_extension_core_functions_scalar_enum.cpp src/duckdb/ub_extension_core_functions_scalar_map.cpp src/duckdb/ub_extension_core_functions_scalar_operators.cpp src/duckdb/ub_extension_core_functions_scalar_date.cpp src/duckdb/ub_extension_core_functions_scalar_list.cpp src/duckdb/ub_extension_core_functions_scalar_blob.cpp src/duckdb/ub_extension_core_functions_scalar_debug.cpp src/duckdb/ub_extension_core_functions_scalar_array.cpp src/duckdb/ub_extension_core_functions_scalar_union.cpp src/duckdb/ub_extension_core_functions_scalar_struct.cpp src/duckdb/ub_extension_core_functions_scalar_bit.cpp src/duckdb/extension/parquet/column_reader.cpp src/duckdb/extension/parquet/column_writer.cpp src/duckdb/extension/parquet/parquet_crypto.cpp src/duckdb/extension/parquet/parquet_extension.cpp src/duckdb/extension/parquet/parquet_metadata.cpp src/duckdb/extension/parquet/parquet_reader.cpp src/duckdb/extension/parquet/parquet_statistics.cpp src/duckdb/extension/parquet/parquet_timestamp.cpp src/duckdb/extension/parquet/parquet_writer.cpp src/duckdb/extension/parquet/serialize_parquet.cpp src/duckdb/extension/parquet/zstd_file_system.cpp src/duckdb/extension/parquet/geo_parquet.cpp src/duckdb/third_party/parquet/parquet_types.cpp src/duckdb/third_party/thrift/thrift/protocol/TProtocol.cpp src/duckdb/third_party/thrift/thrift/transport/TTransportException.cpp src/duckdb/third_party/thrift/thrift/transport/TBufferTransports.cpp src/duckdb/third_party/snappy/snappy.cc src/duckdb/third_party/snappy/snappy-sinksource.cc src/duckdb/third_party/lz4/lz4.cpp src/duckdb/third_party/brotli/common/constants.cpp src/duckdb/third_party/brotli/common/context.cpp src/duckdb/third_party/brotli/common/dictionary.cpp src/duckdb/third_party/brotli/common/platform.cpp src/duckdb/third_party/brotli/common/shared_dictionary.cpp src/duckdb/third_party/brotli/common/transform.cpp src/duckdb/third_party/brotli/dec/bit_reader.cpp src/duckdb/third_party/brotli/dec/decode.cpp src/duckdb/third_party/brotli/dec/huffman.cpp src/duckdb/third_party/brotli/dec/state.cpp src/duckdb/third_party/brotli/enc/backward_references.cpp src/duckdb/third_party/brotli/enc/backward_references_hq.cpp src/duckdb/third_party/brotli/enc/bit_cost.cpp src/duckdb/third_party/brotli/enc/block_splitter.cpp src/duckdb/third_party/brotli/enc/brotli_bit_stream.cpp src/duckdb/third_party/brotli/enc/cluster.cpp src/duckdb/third_party/brotli/enc/command.cpp src/duckdb/third_party/brotli/enc/compound_dictionary.cpp src/duckdb/third_party/brotli/enc/compress_fragment.cpp src/duckdb/third_party/brotli/enc/compress_fragment_two_pass.cpp src/duckdb/third_party/brotli/enc/dictionary_hash.cpp src/duckdb/third_party/brotli/enc/encode.cpp src/duckdb/third_party/brotli/enc/encoder_dict.cpp src/duckdb/third_party/brotli/enc/entropy_encode.cpp src/duckdb/third_party/brotli/enc/fast_log.cpp src/duckdb/third_party/brotli/enc/histogram.cpp src/duckdb/third_party/brotli/enc/literal_cost.cpp src/duckdb/third_party/brotli/enc/memory.cpp src/duckdb/third_party/brotli/enc/metablock.cpp src/duckdb/third_party/brotli/enc/static_dict.cpp src/duckdb/third_party/brotli/enc/utf8_util.cpp src/duckdb/extension/icu/./icu-table-range.cpp src/duckdb/extension/icu/./icu-datefunc.cpp src/duckdb/extension/icu/./icu-datepart.cpp src/duckdb/extension/icu/./icu-datetrunc.cpp src/duckdb/extension/icu/./icu_extension.cpp src/duckdb/extension/icu/./icu-timezone.cpp src/duckdb/extension/icu/./icu-timebucket.cpp src/duckdb/extension/icu/./icu-makedate.cpp src/duckdb/extension/icu/./icu-datesub.cpp src/duckdb/extension/icu/./icu-dateadd.cpp src/duckdb/extension/icu/./icu-list-range.cpp src/duckdb/extension/icu/./icu-strptime.cpp src/duckdb/ub_extension_icu_third_party_icu_common.cpp src/duckdb/ub_extension_icu_third_party_icu_i18n.cpp src/duckdb/extension/icu/third_party/icu/stubdata/stubdata.cpp src/duckdb/extension/json/buffered_json_reader.cpp src/duckdb/extension/json/json_enums.cpp src/duckdb/extension/json/json_extension.cpp src/duckdb/extension/json/json_common.cpp src/duckdb/extension/json/json_functions.cpp src/duckdb/extension/json/json_scan.cpp src/duckdb/extension/json/json_serializer.cpp src/duckdb/extension/json/json_deserializer.cpp src/duckdb/extension/json/serialize_json.cpp src/duckdb/ub_extension_json_json_functions.cpp) set(CMAKE_JAVA_COMPILE_FLAGS -source 1.8 -target 1.8 -encoding utf-8) diff --git a/src/duckdb/src/catalog/catalog.cpp b/src/duckdb/src/catalog/catalog.cpp index 45047f185..0382b24a8 100644 --- a/src/duckdb/src/catalog/catalog.cpp +++ b/src/duckdb/src/catalog/catalog.cpp @@ -26,8 +26,10 @@ #include "duckdb/parser/parsed_data/create_type_info.hpp" #include "duckdb/parser/parsed_data/create_view_info.hpp" #include "duckdb/parser/parsed_data/drop_info.hpp" +#include "duckdb/parser/statement/create_statement.hpp" #include "duckdb/planner/parsed_data/bound_create_table_info.hpp" #include "duckdb/planner/binder.hpp" +#include "duckdb/planner/expression_binder/index_binder.hpp" #include "duckdb/catalog/default/default_types.hpp" #include "duckdb/main/extension_entries.hpp" #include "duckdb/main/extension/generated_extension_loader.hpp" @@ -304,6 +306,14 @@ optional_ptr Catalog::CreateIndex(ClientContext &context, CreateIn return CreateIndex(GetCatalogTransaction(context), info); } +unique_ptr Catalog::BindCreateIndex(Binder &binder, CreateStatement &stmt, TableCatalogEntry &table, + unique_ptr plan) { + D_ASSERT(plan->type == LogicalOperatorType::LOGICAL_GET); + auto create_index_info = unique_ptr_cast(std::move(stmt.info)); + IndexBinder index_binder(binder, binder.context); + return index_binder.BindCreateIndex(binder.context, std::move(create_index_info), table, std::move(plan), nullptr); +} + unique_ptr Catalog::BindAlterAddIndex(Binder &binder, TableCatalogEntry &table_entry, unique_ptr plan, unique_ptr create_info, @@ -953,9 +963,13 @@ optional_ptr Catalog::GetSchema(CatalogEntryRetriever &retri QueryErrorContext error_context) { auto entries = GetCatalogEntries(retriever, catalog_name, schema_name); for (idx_t i = 0; i < entries.size(); i++) { + auto catalog = Catalog::GetCatalogEntry(retriever, entries[i].catalog); + if (!catalog) { + // skip if it is not an attached database + continue; + } auto on_not_found = i + 1 == entries.size() ? if_not_found : OnEntryNotFound::RETURN_NULL; - auto &catalog = Catalog::GetCatalog(retriever, entries[i].catalog); - auto result = catalog.GetSchema(retriever.GetContext(), schema_name, on_not_found, error_context); + auto result = catalog->GetSchema(retriever.GetContext(), schema_name, on_not_found, error_context); if (result) { return result; } diff --git a/src/duckdb/src/catalog/catalog_search_path.cpp b/src/duckdb/src/catalog/catalog_search_path.cpp index dcf2569d8..2f2a98751 100644 --- a/src/duckdb/src/catalog/catalog_search_path.cpp +++ b/src/duckdb/src/catalog/catalog_search_path.cpp @@ -221,17 +221,17 @@ string CatalogSearchPath::GetDefaultCatalog(const string &schema) { } vector CatalogSearchPath::GetCatalogsForSchema(const string &schema) { - vector schemas; + vector catalogs; if (DefaultSchemaGenerator::IsDefaultSchema(schema)) { - schemas.push_back(SYSTEM_CATALOG); + catalogs.push_back(SYSTEM_CATALOG); } else { for (auto &path : paths) { if (StringUtil::CIEquals(path.schema, schema)) { - schemas.push_back(path.catalog); + catalogs.push_back(path.catalog); } } } - return schemas; + return catalogs; } vector CatalogSearchPath::GetSchemasForCatalog(const string &catalog) { diff --git a/src/duckdb/src/catalog/default/default_views.cpp b/src/duckdb/src/catalog/default/default_views.cpp index 718696471..4d57938cf 100644 --- a/src/duckdb/src/catalog/default/default_views.cpp +++ b/src/duckdb/src/catalog/default/default_views.cpp @@ -26,6 +26,7 @@ static const DefaultView internal_views[] = { {DEFAULT_SCHEMA, "duckdb_tables", "SELECT * FROM duckdb_tables() WHERE NOT internal"}, {DEFAULT_SCHEMA, "duckdb_types", "SELECT * FROM duckdb_types()"}, {DEFAULT_SCHEMA, "duckdb_views", "SELECT * FROM duckdb_views() WHERE NOT internal"}, + {DEFAULT_SCHEMA, "duckdb_logs", "SELECT * exclude (l.context_id, c.context_id) FROM duckdb_logs() as l JOIN duckdb_log_contexts() as c ON l.context_id=c.context_id order by timestamp;"}, {"pg_catalog", "pg_am", "SELECT 0 oid, 'art' amname, NULL amhandler, 'i' amtype"}, {"pg_catalog", "pg_attribute", "SELECT table_oid attrelid, column_name attname, data_type_id atttypid, 0 attstattarget, NULL attlen, column_index attnum, 0 attndims, -1 attcacheoff, case when data_type ilike '%decimal%' then numeric_precision*1000+numeric_scale else -1 end atttypmod, false attbyval, NULL attstorage, NULL attalign, NOT is_nullable attnotnull, column_default IS NOT NULL atthasdef, false atthasmissing, '' attidentity, '' attgenerated, false attisdropped, true attislocal, 0 attinhcount, 0 attcollation, NULL attcompression, NULL attacl, NULL attoptions, NULL attfdwoptions, NULL attmissingval FROM duckdb_columns()"}, {"pg_catalog", "pg_attrdef", "SELECT column_index oid, table_oid adrelid, column_index adnum, column_default adbin from duckdb_columns() where column_default is not null;"}, diff --git a/src/duckdb/src/common/arrow/arrow_appender.cpp b/src/duckdb/src/common/arrow/arrow_appender.cpp index 632bffc66..83f190b57 100644 --- a/src/duckdb/src/common/arrow/arrow_appender.cpp +++ b/src/duckdb/src/common/arrow/arrow_appender.cpp @@ -7,6 +7,7 @@ #include "duckdb/function/table/arrow.hpp" #include "duckdb/common/arrow/appender/append_data.hpp" #include "duckdb/common/arrow/appender/list.hpp" +#include "duckdb/function/table/arrow/arrow_duck_schema.hpp" namespace duckdb { @@ -14,10 +15,17 @@ namespace duckdb { // ArrowAppender //===--------------------------------------------------------------------===// -ArrowAppender::ArrowAppender(vector types_p, const idx_t initial_capacity, ClientProperties options) - : types(std::move(types_p)) { - for (auto &type : types) { - auto entry = InitializeChild(type, initial_capacity, options); +ArrowAppender::ArrowAppender(vector types_p, const idx_t initial_capacity, ClientProperties options, + unordered_map> extension_type_cast) + : types(std::move(types_p)), options(options) { + for (idx_t i = 0; i < types.size(); i++) { + unique_ptr entry; + bool bitshift_boolean = types[i].id() == LogicalTypeId::BOOLEAN && !options.arrow_lossless_conversion; + if (extension_type_cast.find(i) != extension_type_cast.end() && !bitshift_boolean) { + entry = InitializeChild(types[i], initial_capacity, options, extension_type_cast[i]); + } else { + entry = InitializeChild(types[i], initial_capacity, options); + } root_data.push_back(std::move(entry)); } } @@ -26,11 +34,18 @@ ArrowAppender::~ArrowAppender() { } //! Append a data chunk to the underlying arrow array -void ArrowAppender::Append(DataChunk &input, idx_t from, idx_t to, idx_t input_size) { +void ArrowAppender::Append(DataChunk &input, const idx_t from, const idx_t to, const idx_t input_size) { D_ASSERT(types == input.GetTypes()); D_ASSERT(to >= from); for (idx_t i = 0; i < input.ColumnCount(); i++) { - root_data[i]->append_vector(*root_data[i], input.data[i], from, to, input_size); + if (root_data[i]->extension_data && root_data[i]->extension_data->duckdb_to_arrow) { + Vector input_data(root_data[i]->extension_data->GetInternalType()); + root_data[i]->extension_data->duckdb_to_arrow(*options.client_context, input.data[i], input_data, + input_size); + root_data[i]->append_vector(*root_data[i], input_data, from, to, input_size); + } else { + root_data[i]->append_vector(*root_data[i], input.data[i], from, to, input_size); + } } row_count += to - from; } @@ -285,13 +300,19 @@ static void InitializeFunctionPointers(ArrowAppendData &append_data, const Logic } unique_ptr ArrowAppender::InitializeChild(const LogicalType &type, const idx_t capacity, - ClientProperties &options) { + ClientProperties &options, + const shared_ptr &extension_type) { auto result = make_uniq(options); - InitializeFunctionPointers(*result, type); + LogicalType array_type = type; + if (extension_type) { + array_type = extension_type->GetInternalType(); + } + InitializeFunctionPointers(*result, array_type); + result->extension_data = extension_type; const auto byte_count = (capacity + 7) / 8; result->GetValidityBuffer().reserve(byte_count); - result->initialize(*result, type, capacity); + result->initialize(*result, array_type, capacity); return result; } diff --git a/src/duckdb/src/common/arrow/arrow_converter.cpp b/src/duckdb/src/common/arrow/arrow_converter.cpp index 582daf34b..a693034a9 100644 --- a/src/duckdb/src/common/arrow/arrow_converter.cpp +++ b/src/duckdb/src/common/arrow/arrow_converter.cpp @@ -9,14 +9,17 @@ #include "duckdb/common/types/vector_cache.hpp" #include "duckdb/common/unordered_map.hpp" #include "duckdb/common/vector.hpp" -#include +#include "duckdb/main/config.hpp" + #include "duckdb/common/arrow/arrow_appender.hpp" #include "duckdb/common/arrow/schema_metadata.hpp" - +#include "duckdb/main/client_context.hpp" namespace duckdb { -void ArrowConverter::ToArrowArray(DataChunk &input, ArrowArray *out_array, ClientProperties options) { - ArrowAppender appender(input.GetTypes(), input.size(), std::move(options)); +void ArrowConverter::ToArrowArray( + DataChunk &input, ArrowArray *out_array, ClientProperties options, + const unordered_map> &extension_type_cast) { + ArrowAppender appender(input.GetTypes(), input.size(), std::move(options), extension_type_cast); appender.Append(input, 0, input.size(), input.size()); *out_array = appender.Finalize(); } @@ -30,24 +33,6 @@ unsafe_unique_array AddName(const string &name) { return name_ptr; } -//===--------------------------------------------------------------------===// -// Arrow Schema -//===--------------------------------------------------------------------===// -struct DuckDBArrowSchemaHolder { - // unused in children - vector children; - // unused in children - vector children_ptrs; - //! used for nested structures - std::list> nested_children; - std::list> nested_children_ptr; - //! This holds strings created to represent decimal types - vector> owned_type_names; - vector> owned_column_names; - //! This holds any values created for metadata info - vector> metadata_info; -}; - static void ReleaseDuckDBArrowSchema(ArrowSchema *schema) { if (!schema || !schema->release) { return; @@ -74,10 +59,10 @@ void InitializeChild(ArrowSchema &child, DuckDBArrowSchemaHolder &root_holder, c } void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, const LogicalType &type, - const ClientProperties &options); + ClientProperties &options, ClientContext &context); void SetArrowMapFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, const LogicalType &type, - const ClientProperties &options) { + ClientProperties &options, ClientContext &context) { child.format = "+m"; //! Map has one child which is a struct child.n_children = 1; @@ -88,14 +73,38 @@ void SetArrowMapFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, InitializeChild(root_holder.nested_children.back()[0], root_holder); child.children = &root_holder.nested_children_ptr.back()[0]; child.children[0]->name = "entries"; - SetArrowFormat(root_holder, **child.children, ListType::GetChildType(type), options); + SetArrowFormat(root_holder, **child.children, ListType::GetChildType(type), options, context); +} + +bool SetArrowExtension(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, const LogicalType &type, + ClientContext &context) { + auto &config = DBConfig::GetConfig(context); + if (config.HasArrowExtension(type.id())) { + auto arrow_extension = config.GetArrowExtension(type.id()); + arrow_extension.PopulateArrowSchema(root_holder, child, type, context, arrow_extension); + return true; + } + return false; } void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, const LogicalType &type, - const ClientProperties &options) { + ClientProperties &options, ClientContext &context) { + if (type.HasAlias()) { + // If it is a json type, we only export it as json if arrow_lossless_conversion = True + if (!(type.IsJSONType() && !options.arrow_lossless_conversion)) { + // If the type has an alias, we check if it is an Arrow-Type extension + if (SetArrowExtension(root_holder, child, type, context)) { + return; + } + } + } switch (type.id()) { case LogicalTypeId::BOOLEAN: - child.format = "b"; + if (options.arrow_lossless_conversion) { + SetArrowExtension(root_holder, child, type, context); + } else { + child.format = "b"; + } break; case LogicalTypeId::TINYINT: child.format = "c"; @@ -126,43 +135,18 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co break; case LogicalTypeId::HUGEINT: { if (options.arrow_lossless_conversion) { - child.format = "w:16"; - auto schema_metadata = ArrowSchemaMetadata::DuckDBInternalType("hugeint"); - root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata()); - child.metadata = root_holder.metadata_info.back().get(); + SetArrowExtension(root_holder, child, type, context); } else { child.format = "d:38,0"; } break; } - case LogicalTypeId::UHUGEINT: { - child.format = "w:16"; - auto schema_metadata = ArrowSchemaMetadata::DuckDBInternalType("uhugeint"); - root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata()); - child.metadata = root_holder.metadata_info.back().get(); - break; - } - case LogicalTypeId::VARINT: { - if (options.arrow_offset_size == ArrowOffsetSize::LARGE) { - child.format = "Z"; - } else { - child.format = "z"; - } - auto schema_metadata = ArrowSchemaMetadata::DuckDBInternalType("varint"); - root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata()); - child.metadata = root_holder.metadata_info.back().get(); - break; - } case LogicalTypeId::DOUBLE: child.format = "g"; break; case LogicalTypeId::UUID: { if (options.arrow_lossless_conversion) { - // This is a canonical extension, hence needs the "arrow." prefix - child.format = "w:16"; - auto schema_metadata = ArrowSchemaMetadata::ArrowCanonicalType("arrow.uuid"); - root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata()); - child.metadata = root_holder.metadata_info.back().get(); + SetArrowExtension(root_holder, child, type, context); } else { if (options.produce_arrow_string_view) { child.format = "vu"; @@ -177,11 +161,6 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co break; } case LogicalTypeId::VARCHAR: - if (type.IsJSONType() && options.arrow_lossless_conversion) { - auto schema_metadata = ArrowSchemaMetadata::ArrowCanonicalType("arrow.json"); - root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata()); - child.metadata = root_holder.metadata_info.back().get(); - } if (options.produce_arrow_string_view) { child.format = "vu"; } else { @@ -197,10 +176,7 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co break; case LogicalTypeId::TIME_TZ: { if (options.arrow_lossless_conversion) { - child.format = "w:8"; - auto schema_metadata = ArrowSchemaMetadata::DuckDBInternalType("time_tz"); - root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata()); - child.metadata = root_holder.metadata_info.back().get(); + SetArrowExtension(root_holder, child, type, context); } else { child.format = "ttu"; } @@ -250,16 +226,16 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co } break; case LogicalTypeId::BIT: { - if (options.arrow_offset_size == ArrowOffsetSize::LARGE) { - child.format = "Z"; - } else { - child.format = "z"; - } if (options.arrow_lossless_conversion) { - auto schema_metadata = ArrowSchemaMetadata::DuckDBInternalType("bit"); - root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata()); - child.metadata = root_holder.metadata_info.back().get(); + SetArrowExtension(root_holder, child, type, context); + } else { + if (options.arrow_offset_size == ArrowOffsetSize::LARGE) { + child.format = "Z"; + } else { + child.format = "z"; + } } + break; } case LogicalTypeId::LIST: { @@ -284,7 +260,7 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co InitializeChild(root_holder.nested_children.back()[0], root_holder); child.children = &root_holder.nested_children_ptr.back()[0]; child.children[0]->name = "l"; - SetArrowFormat(root_holder, **child.children, ListType::GetChildType(type), options); + SetArrowFormat(root_holder, **child.children, ListType::GetChildType(type), options, context); break; } case LogicalTypeId::STRUCT: { @@ -306,7 +282,7 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co root_holder.owned_type_names.push_back(AddName(child_types[type_idx].first)); child.children[type_idx]->name = root_holder.owned_type_names.back().get(); - SetArrowFormat(root_holder, *child.children[type_idx], child_types[type_idx].second, options); + SetArrowFormat(root_holder, *child.children[type_idx], child_types[type_idx].second, options, context); } break; } @@ -324,11 +300,11 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co root_holder.nested_children_ptr.back().push_back(&root_holder.nested_children.back()[0]); InitializeChild(root_holder.nested_children.back()[0], root_holder); child.children = &root_holder.nested_children_ptr.back()[0]; - SetArrowFormat(root_holder, **child.children, child_type, options); + SetArrowFormat(root_holder, **child.children, child_type, options, context); break; } case LogicalTypeId::MAP: { - SetArrowMapFormat(root_holder, child, type, options); + SetArrowMapFormat(root_holder, child, type, options, context); break; } case LogicalTypeId::UNION: { @@ -351,7 +327,7 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co root_holder.owned_type_names.push_back(AddName(child_types[type_idx].first)); child.children[type_idx]->name = root_holder.owned_type_names.back().get(); - SetArrowFormat(root_holder, *child.children[type_idx], child_types[type_idx].second, options); + SetArrowFormat(root_holder, *child.children[type_idx], child_types[type_idx].second, options, context); format += to_string(type_idx) + ","; } @@ -387,17 +363,22 @@ void SetArrowFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, co child.dictionary->format = "u"; break; } - default: - throw NotImplementedException("Unsupported Arrow type " + type.ToString()); + default: { + // It is possible we can export this type as a registered extension + auto success = SetArrowExtension(root_holder, child, type, context); + if (!success) { + throw NotImplementedException("Unsupported Arrow type %s", type.ToString()); + } + } } } void ArrowConverter::ToArrowSchema(ArrowSchema *out_schema, const vector &types, - const vector &names, const ClientProperties &options) { + const vector &names, ClientProperties &options) { D_ASSERT(out_schema); D_ASSERT(types.size() == names.size()); - idx_t column_count = types.size(); - // Allocate as unique_ptr first to cleanup properly on error + const idx_t column_count = types.size(); + // Allocate as unique_ptr first to clean-up properly on error auto root_holder = make_uniq(); // Allocate the children @@ -421,7 +402,7 @@ void ArrowConverter::ToArrowSchema(ArrowSchema *out_schema, const vectorowned_column_names.push_back(AddName(names[col_idx])); auto &child = root_holder->children[col_idx]; InitializeChild(child, *root_holder, names[col_idx]); - SetArrowFormat(*root_holder, child, types[col_idx], options); + SetArrowFormat(*root_holder, child, types[col_idx], options, *options.client_context); } // Release ownership to caller diff --git a/src/duckdb/src/common/arrow/arrow_merge_event.cpp b/src/duckdb/src/common/arrow/arrow_merge_event.cpp index 1315ad1ad..6a5c8fab3 100644 --- a/src/duckdb/src/common/arrow/arrow_merge_event.cpp +++ b/src/duckdb/src/common/arrow/arrow_merge_event.cpp @@ -21,8 +21,9 @@ void ArrowBatchTask::ProduceRecordBatches() { for (auto &index : record_batch_indices) { auto &array = arrays[index]; D_ASSERT(array); - idx_t count; - count = ArrowUtil::FetchChunk(scan_state, arrow_options, batch_size, &array->arrow_array); + const idx_t count = ArrowUtil::FetchChunk( + scan_state, arrow_options, batch_size, &array->arrow_array, + ArrowTypeExtensionData::GetExtensionTypes(event->GetClientContext(), scan_state.Types())); (void)count; D_ASSERT(count != 0); } diff --git a/src/duckdb/src/common/arrow/arrow_type_extension.cpp b/src/duckdb/src/common/arrow/arrow_type_extension.cpp new file mode 100644 index 000000000..4483f8644 --- /dev/null +++ b/src/duckdb/src/common/arrow/arrow_type_extension.cpp @@ -0,0 +1,361 @@ +#include "duckdb/common/arrow/arrow_type_extension.hpp" +#include "duckdb/common/types/hash.hpp" +#include "duckdb/main/config.hpp" +#include "duckdb/function/table/arrow/arrow_duck_schema.hpp" +#include "duckdb/main/client_context.hpp" +#include "duckdb/common/arrow/arrow_converter.hpp" +#include "duckdb/common/arrow/schema_metadata.hpp" +#include "duckdb/common/types/vector.hpp" + +namespace duckdb { + +ArrowTypeExtension::ArrowTypeExtension(string extension_name, string arrow_format, + shared_ptr type) + : extension_metadata(std::move(extension_name), {}, {}, std::move(arrow_format)), type_extension(std::move(type)) { +} + +ArrowExtensionMetadata::ArrowExtensionMetadata(string extension_name, string vendor_name, string type_name, + string arrow_format) + : extension_name(std::move(extension_name)), vendor_name(std::move(vendor_name)), type_name(std::move(type_name)), + arrow_format(std::move(arrow_format)) { +} + +hash_t ArrowExtensionMetadata::GetHash() const { + const auto h_extension = Hash(extension_name.c_str()); + const auto h_vendor = Hash(vendor_name.c_str()); + const auto h_type = Hash(type_name.c_str()); + // Most arrow extensions are unique on the extension name + // However we use arrow.opaque as all the non-canonical extensions, hence we do a hash-aroo of all. + return CombineHash(h_extension, CombineHash(h_vendor, h_type)); +} + +TypeInfo::TypeInfo() : type() { +} + +TypeInfo::TypeInfo(const LogicalType &type_p) : alias(type_p.GetAlias()), type(type_p.id()) { +} + +TypeInfo::TypeInfo(string alias) : alias(std::move(alias)), type(LogicalTypeId::ANY) { +} + +hash_t TypeInfo::GetHash() const { + const auto h_type_id = Hash(type); + const auto h_alias = Hash(alias.c_str()); + return CombineHash(h_type_id, h_alias); +} + +bool TypeInfo::operator==(const TypeInfo &other) const { + return alias == other.alias && type == other.type; +} + +string ArrowExtensionMetadata::ToString() const { + std::ostringstream info; + info << "Extension Name: " << extension_name << "\n"; + if (!vendor_name.empty()) { + info << "Vendor: " << vendor_name << "\n"; + } + if (!type_name.empty()) { + info << "Type: " << type_name << "\n"; + } + if (!arrow_format.empty()) { + info << "Format: " << arrow_format << "\n"; + } + return info.str(); +} + +string ArrowExtensionMetadata::GetExtensionName() const { + return extension_name; +} + +string ArrowExtensionMetadata::GetVendorName() const { + return vendor_name; +} + +string ArrowExtensionMetadata::GetTypeName() const { + return type_name; +} + +string ArrowExtensionMetadata::GetArrowFormat() const { + return arrow_format; +} + +void ArrowExtensionMetadata::SetArrowFormat(string arrow_format_p) { + arrow_format = std::move(arrow_format_p); +} + +bool ArrowExtensionMetadata::IsCanonical() const { + D_ASSERT((!vendor_name.empty() && !type_name.empty()) || (vendor_name.empty() && type_name.empty())); + return vendor_name.empty(); +} + +bool ArrowExtensionMetadata::operator==(const ArrowExtensionMetadata &other) const { + return extension_name == other.extension_name && type_name == other.type_name && vendor_name == other.vendor_name; +} + +ArrowTypeExtension::ArrowTypeExtension(string vendor_name, string type_name, string arrow_format, + shared_ptr type) + : extension_metadata(ArrowExtensionMetadata::ARROW_EXTENSION_NON_CANONICAL, std::move(vendor_name), + std::move(type_name), std::move(arrow_format)), + type_extension(std::move(type)) { +} + +ArrowTypeExtension::ArrowTypeExtension(string extension_name, populate_arrow_schema_t populate_arrow_schema, + get_type_t get_type, shared_ptr type) + : populate_arrow_schema(populate_arrow_schema), get_type(get_type), + extension_metadata(std::move(extension_name), {}, {}, {}), type_extension(std::move(type)) { +} + +ArrowTypeExtension::ArrowTypeExtension(string vendor_name, string type_name, + populate_arrow_schema_t populate_arrow_schema, get_type_t get_type, + shared_ptr type, cast_arrow_duck_t arrow_to_duckdb, + cast_duck_arrow_t duckdb_to_arrow) + : populate_arrow_schema(populate_arrow_schema), get_type(get_type), + extension_metadata(ArrowExtensionMetadata::ARROW_EXTENSION_NON_CANONICAL, std::move(vendor_name), + std::move(type_name), {}), + type_extension(std::move(type)) { + type_extension->arrow_to_duckdb = arrow_to_duckdb; + type_extension->duckdb_to_arrow = duckdb_to_arrow; +} + +ArrowExtensionMetadata ArrowTypeExtension::GetInfo() const { + return extension_metadata; +} + +shared_ptr ArrowTypeExtension::GetType(const ArrowSchema &schema, + const ArrowSchemaMetadata &schema_metadata) const { + if (get_type) { + return get_type(schema, schema_metadata); + } + // FIXME: THis is not good + auto duckdb_type = type_extension->GetDuckDBType(); + return make_shared_ptr(duckdb_type); +} + +shared_ptr ArrowTypeExtension::GetTypeExtension() const { + return type_extension; +} + +LogicalTypeId ArrowTypeExtension::GetLogicalTypeId() const { + return type_extension->GetDuckDBType().id(); +} + +LogicalType ArrowTypeExtension::GetLogicalType() const { + return type_extension->GetDuckDBType(); +} + +bool ArrowTypeExtension::HasType() const { + return type_extension.get() != nullptr; +} + +void ArrowTypeExtension::PopulateArrowSchema(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, + const LogicalType &duckdb_type, ClientContext &context, + const ArrowTypeExtension &extension) { + if (extension.populate_arrow_schema) { + extension.populate_arrow_schema(root_holder, child, duckdb_type, context, extension); + return; + } + + auto format = make_unsafe_uniq_array(extension.extension_metadata.GetArrowFormat().size() + 1); + idx_t i = 0; + for (const auto &c : extension.extension_metadata.GetArrowFormat()) { + format[i++] = c; + } + format[i++] = '\0'; + // We do the default way of populating the schema + root_holder.extension_format.emplace_back(std::move(format)); + + child.format = root_holder.extension_format.back().get(); + ArrowSchemaMetadata schema_metadata; + if (extension.extension_metadata.IsCanonical()) { + schema_metadata = ArrowSchemaMetadata::ArrowCanonicalType(extension.extension_metadata.GetExtensionName()); + } else { + schema_metadata = ArrowSchemaMetadata::NonCanonicalType(extension.extension_metadata.GetTypeName(), + extension.extension_metadata.GetVendorName()); + } + root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata()); + child.metadata = root_holder.metadata_info.back().get(); +} + +void DBConfig::RegisterArrowExtension(const ArrowTypeExtension &extension) const { + lock_guard l(encoding_functions->lock); + auto extension_info = extension.GetInfo(); + if (arrow_extensions->type_extensions.find(extension_info) != arrow_extensions->type_extensions.end()) { + throw NotImplementedException("Arrow Extension with configuration %s is already registered", + extension_info.ToString()); + } + arrow_extensions->type_extensions[extension_info] = extension; + if (extension.HasType()) { + const TypeInfo type_info(extension.GetLogicalType()); + arrow_extensions->type_to_info[type_info].push_back(extension_info); + return; + } + const TypeInfo type_info(extension.GetInfo().GetExtensionName()); + arrow_extensions->type_to_info[type_info].push_back(extension_info); +} + +ArrowTypeExtension DBConfig::GetArrowExtension(ArrowExtensionMetadata info) const { + if (arrow_extensions->type_extensions.find(info) == arrow_extensions->type_extensions.end()) { + info.SetArrowFormat(""); + if (arrow_extensions->type_extensions.find(info) == arrow_extensions->type_extensions.end()) { + throw NotImplementedException("Arrow Extension with configuration:\n%s not yet registered", + info.ToString()); + } + } + return arrow_extensions->type_extensions[info]; +} + +ArrowTypeExtension DBConfig::GetArrowExtension(const LogicalType &type) const { + TypeInfo type_info(type); + if (!arrow_extensions->type_to_info[type_info].empty()) { + return GetArrowExtension(arrow_extensions->type_to_info[type_info].front()); + } + type_info.type = LogicalTypeId::ANY; + return GetArrowExtension(arrow_extensions->type_to_info[type_info].front()); +} + +bool DBConfig::HasArrowExtension(const LogicalType &type) const { + TypeInfo type_info(type); + if (!arrow_extensions->type_to_info[type_info].empty()) { + return true; + } + type_info.type = LogicalTypeId::ANY; + return !arrow_extensions->type_to_info[type_info].empty(); +} + +struct ArrowJson { + static shared_ptr GetType(const ArrowSchema &schema, const ArrowSchemaMetadata &schema_metadata) { + const auto format = string(schema.format); + if (format == "u") { + return make_shared_ptr(LogicalType::JSON(), + make_uniq(ArrowVariableSizeType::NORMAL)); + } else if (format == "U") { + return make_shared_ptr(LogicalType::JSON(), + make_uniq(ArrowVariableSizeType::NORMAL)); + } else if (format == "vu") { + return make_shared_ptr(LogicalType::JSON(), + make_uniq(ArrowVariableSizeType::NORMAL)); + } + throw InvalidInputException("Arrow extension type \"%s\" not supported for arrow.json", format.c_str()); + } + + static void PopulateSchema(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &schema, const LogicalType &type, + ClientContext &context, const ArrowTypeExtension &extension) { + const ArrowSchemaMetadata schema_metadata = + ArrowSchemaMetadata::ArrowCanonicalType(extension.GetInfo().GetExtensionName()); + root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata()); + schema.metadata = root_holder.metadata_info.back().get(); + const auto options = context.GetClientProperties(); + if (options.produce_arrow_string_view) { + schema.format = "vu"; + } else { + if (options.arrow_offset_size == ArrowOffsetSize::LARGE) { + schema.format = "U"; + } else { + schema.format = "u"; + } + } + } +}; + +struct ArrowBit { + static shared_ptr GetType(const ArrowSchema &schema, const ArrowSchemaMetadata &schema_metadata) { + const auto format = string(schema.format); + if (format == "z") { + return make_shared_ptr(LogicalType::BIT, + make_uniq(ArrowVariableSizeType::NORMAL)); + } else if (format == "Z") { + return make_shared_ptr(LogicalType::BIT, + make_uniq(ArrowVariableSizeType::SUPER_SIZE)); + } + throw InvalidInputException("Arrow extension type \"%s\" not supported for BIT type", format.c_str()); + } + + static void PopulateSchema(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &schema, const LogicalType &type, + ClientContext &context, const ArrowTypeExtension &extension) { + const ArrowSchemaMetadata schema_metadata = ArrowSchemaMetadata::NonCanonicalType( + extension.GetInfo().GetTypeName(), extension.GetInfo().GetVendorName()); + root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata()); + schema.metadata = root_holder.metadata_info.back().get(); + const auto options = context.GetClientProperties(); + if (options.arrow_offset_size == ArrowOffsetSize::LARGE) { + schema.format = "Z"; + } else { + schema.format = "z"; + } + } +}; + +struct ArrowVarint { + static shared_ptr GetType(const ArrowSchema &schema, const ArrowSchemaMetadata &schema_metadata) { + const auto format = string(schema.format); + if (format == "z") { + return make_shared_ptr(LogicalType::VARINT, + make_uniq(ArrowVariableSizeType::NORMAL)); + } else if (format == "Z") { + return make_shared_ptr(LogicalType::VARINT, + make_uniq(ArrowVariableSizeType::SUPER_SIZE)); + } + throw InvalidInputException("Arrow extension type \"%s\" not supported for Varint", format.c_str()); + } + + static void PopulateSchema(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &schema, const LogicalType &type, + ClientContext &context, const ArrowTypeExtension &extension) { + const ArrowSchemaMetadata schema_metadata = ArrowSchemaMetadata::NonCanonicalType( + extension.GetInfo().GetTypeName(), extension.GetInfo().GetVendorName()); + root_holder.metadata_info.emplace_back(schema_metadata.SerializeMetadata()); + schema.metadata = root_holder.metadata_info.back().get(); + const auto options = context.GetClientProperties(); + if (options.arrow_offset_size == ArrowOffsetSize::LARGE) { + schema.format = "Z"; + } else { + schema.format = "z"; + } + } +}; + +struct ArrowBool8 { + static void ArrowToDuck(ClientContext &context, Vector &source, Vector &result, idx_t count) { + auto source_ptr = reinterpret_cast(FlatVector::GetData(source)); + auto result_ptr = reinterpret_cast(FlatVector::GetData(result)); + for (idx_t i = 0; i < count; i++) { + result_ptr[i] = source_ptr[i]; + } + } + static void DuckToArrow(ClientContext &context, Vector &source, Vector &result, idx_t count) { + UnifiedVectorFormat format; + source.ToUnifiedFormat(count, format); + FlatVector::SetValidity(result, format.validity); + auto source_ptr = reinterpret_cast(format.data); + auto result_ptr = reinterpret_cast(FlatVector::GetData(result)); + for (idx_t i = 0; i < count; i++) { + result_ptr[i] = static_cast(source_ptr[i]); + } + } +}; + +void ArrowTypeExtensionSet::Initialize(const DBConfig &config) { + // Types that are 1:1 + config.RegisterArrowExtension({"arrow.uuid", "w:16", make_shared_ptr(LogicalType::UUID)}); + config.RegisterArrowExtension( + {"arrow.bool8", "c", + make_shared_ptr(LogicalType::BOOLEAN, LogicalType::TINYINT, ArrowBool8::ArrowToDuck, + ArrowBool8::DuckToArrow)}); + + config.RegisterArrowExtension( + {"DuckDB", "hugeint", "w:16", make_shared_ptr(LogicalType::HUGEINT)}); + config.RegisterArrowExtension( + {"DuckDB", "uhugeint", "w:16", make_shared_ptr(LogicalType::UHUGEINT)}); + config.RegisterArrowExtension( + {"DuckDB", "time_tz", "w:8", make_shared_ptr(LogicalType::TIME_TZ)}); + + // Types that are 1:n + config.RegisterArrowExtension({"arrow.json", &ArrowJson::PopulateSchema, &ArrowJson::GetType, + make_shared_ptr(LogicalType::VARCHAR)}); + + config.RegisterArrowExtension({"DuckDB", "bit", &ArrowBit::PopulateSchema, &ArrowBit::GetType, + make_shared_ptr(LogicalType::BIT), nullptr, nullptr}); + + config.RegisterArrowExtension({"DuckDB", "varint", &ArrowVarint::PopulateSchema, &ArrowVarint::GetType, + make_shared_ptr(LogicalType::VARINT), nullptr, nullptr}); +} +} // namespace duckdb diff --git a/src/duckdb/src/common/arrow/arrow_util.cpp b/src/duckdb/src/common/arrow/arrow_util.cpp index 423a6dd2c..267479d9e 100644 --- a/src/duckdb/src/common/arrow/arrow_util.cpp +++ b/src/duckdb/src/common/arrow/arrow_util.cpp @@ -1,14 +1,17 @@ +#include + #include "duckdb/common/arrow/arrow_util.hpp" #include "duckdb/common/arrow/arrow_appender.hpp" #include "duckdb/common/types/data_chunk.hpp" - +#include "duckdb/function/table/arrow/arrow_duck_schema.hpp" namespace duckdb { bool ArrowUtil::TryFetchChunk(ChunkScanState &scan_state, ClientProperties options, idx_t batch_size, ArrowArray *out, - idx_t &count, ErrorData &error) { + idx_t &count, ErrorData &error, + unordered_map> extension_type_cast) { count = 0; - ArrowAppender appender(scan_state.Types(), batch_size, std::move(options)); - auto remaining_tuples_in_chunk = scan_state.RemainingInChunk(); + ArrowAppender appender(scan_state.Types(), batch_size, std::move(options), std::move(extension_type_cast)); + const auto remaining_tuples_in_chunk = scan_state.RemainingInChunk(); if (remaining_tuples_in_chunk) { // We start by scanning the non-finished current chunk idx_t cur_consumption = MinValue(remaining_tuples_in_chunk, batch_size); @@ -48,10 +51,11 @@ bool ArrowUtil::TryFetchChunk(ChunkScanState &scan_state, ClientProperties optio return true; } -idx_t ArrowUtil::FetchChunk(ChunkScanState &scan_state, ClientProperties options, idx_t chunk_size, ArrowArray *out) { +idx_t ArrowUtil::FetchChunk(ChunkScanState &scan_state, ClientProperties options, idx_t chunk_size, ArrowArray *out, + const unordered_map> &extension_type_cast) { ErrorData error; idx_t result_count; - if (!TryFetchChunk(scan_state, std::move(options), chunk_size, out, result_count, error)) { + if (!TryFetchChunk(scan_state, std::move(options), chunk_size, out, result_count, error, extension_type_cast)) { error.Throw(); } return result_count; diff --git a/src/duckdb/src/common/arrow/arrow_wrapper.cpp b/src/duckdb/src/common/arrow/arrow_wrapper.cpp index 2d17076f4..5cbc45a21 100644 --- a/src/duckdb/src/common/arrow/arrow_wrapper.cpp +++ b/src/duckdb/src/common/arrow/arrow_wrapper.cpp @@ -11,6 +11,7 @@ #include "duckdb/common/arrow/arrow_appender.hpp" #include "duckdb/main/query_result.hpp" #include "duckdb/main/chunk_scan_state/query_result.hpp" +#include "duckdb/function/table/arrow/arrow_duck_schema.hpp" namespace duckdb { @@ -131,8 +132,8 @@ int ResultArrowArrayStreamWrapper::MyStreamGetNext(struct ArrowArrayStream *stre } idx_t result_count; ErrorData error; - if (!ArrowUtil::TryFetchChunk(scan_state, result.client_properties, my_stream->batch_size, out, result_count, - error)) { + if (!ArrowUtil::TryFetchChunk(scan_state, result.client_properties, my_stream->batch_size, out, result_count, error, + my_stream->extension_types)) { D_ASSERT(error.HasError()); my_stream->last_error = error; return -1; @@ -175,6 +176,9 @@ ResultArrowArrayStreamWrapper::ResultArrowArrayStreamWrapper(unique_ptrclient_properties.client_context, result->types); } } // namespace duckdb diff --git a/src/duckdb/src/common/arrow/physical_arrow_collector.cpp b/src/duckdb/src/common/arrow/physical_arrow_collector.cpp index d82246b4c..50a663b0b 100644 --- a/src/duckdb/src/common/arrow/physical_arrow_collector.cpp +++ b/src/duckdb/src/common/arrow/physical_arrow_collector.cpp @@ -37,7 +37,8 @@ SinkResultType PhysicalArrowCollector::Sink(ExecutionContext &context, DataChunk auto properties = context.client.GetClientProperties(); D_ASSERT(processed < count); auto initial_capacity = MinValue(record_batch_size, count - processed); - appender = make_uniq(types, initial_capacity, properties); + appender = make_uniq(types, initial_capacity, properties, + ArrowTypeExtensionData::GetExtensionTypes(context.client, types)); } // Figure out how much we can still append to this chunk diff --git a/src/duckdb/src/common/arrow/schema_metadata.cpp b/src/duckdb/src/common/arrow/schema_metadata.cpp index 836f89f2c..4e259743f 100644 --- a/src/duckdb/src/common/arrow/schema_metadata.cpp +++ b/src/duckdb/src/common/arrow/schema_metadata.cpp @@ -37,6 +37,7 @@ ArrowSchemaMetadata::ArrowSchemaMetadata(const char *metadata) { void ArrowSchemaMetadata::AddOption(const string &key, const string &value) { schema_metadata_map[key] = value; } + string ArrowSchemaMetadata::GetOption(const string &key) const { auto it = schema_metadata_map.find(key); if (it != schema_metadata_map.end()) { @@ -46,10 +47,6 @@ string ArrowSchemaMetadata::GetOption(const string &key) const { } } -string ArrowSchemaMetadata::GetExtensionName() const { - return GetOption(ARROW_EXTENSION_NAME); -} - ArrowSchemaMetadata ArrowSchemaMetadata::ArrowCanonicalType(const string &extension_name) { ArrowSchemaMetadata metadata; metadata.AddOption(ARROW_EXTENSION_NAME, extension_name); @@ -57,38 +54,26 @@ ArrowSchemaMetadata ArrowSchemaMetadata::ArrowCanonicalType(const string &extens return metadata; } -ArrowSchemaMetadata ArrowSchemaMetadata::DuckDBInternalType(const string &type_name) { +ArrowSchemaMetadata ArrowSchemaMetadata::NonCanonicalType(const string &type_name, const string &vendor_name) { ArrowSchemaMetadata metadata; - metadata.AddOption(ARROW_EXTENSION_NAME, ARROW_EXTENSION_NON_CANONICAL); + metadata.AddOption(ARROW_EXTENSION_NAME, ArrowExtensionMetadata::ARROW_EXTENSION_NON_CANONICAL); // We have to set the metadata key with type_name and vendor_name. - metadata.extension_metadata_map["vendor_name"] = "DuckDB"; + metadata.extension_metadata_map["vendor_name"] = vendor_name; metadata.extension_metadata_map["type_name"] = type_name; metadata.AddOption(ARROW_METADATA_KEY, StringUtil::ToJSONMap(metadata.extension_metadata_map)); return metadata; } -bool ArrowSchemaMetadata::IsNonCanonicalType(const string &type, const string &vendor) const { - if (schema_metadata_map.find(ARROW_EXTENSION_NAME) == schema_metadata_map.end()) { - return false; - } - if (schema_metadata_map.find(ARROW_EXTENSION_NAME)->second != ARROW_EXTENSION_NON_CANONICAL) { - return false; - } - if (extension_metadata_map.find("type_name") == extension_metadata_map.end() || - extension_metadata_map.find("vendor_name") == extension_metadata_map.end()) { - return false; - } - auto vendor_name = extension_metadata_map.find("vendor_name")->second; - auto type_name = extension_metadata_map.find("type_name")->second; - return vendor_name == vendor && type_name == type; -} - bool ArrowSchemaMetadata::HasExtension() const { auto arrow_extension = GetOption(ArrowSchemaMetadata::ARROW_EXTENSION_NAME); - // FIXME: We are currently ignoring the ogc extensions return !arrow_extension.empty() && !StringUtil::StartsWith(arrow_extension, "ogc"); } +ArrowExtensionMetadata ArrowSchemaMetadata::GetExtensionInfo(string format) { + return {schema_metadata_map[ARROW_EXTENSION_NAME], extension_metadata_map["vendor_name"], + extension_metadata_map["type_name"], std::move(format)}; +} + unsafe_unique_array ArrowSchemaMetadata::SerializeMetadata() const { // First we have to figure out the total size: // 1. number of key-value pairs (int32) diff --git a/src/duckdb/src/common/enum_util.cpp b/src/duckdb/src/common/enum_util.cpp index 1fd91919b..88660f982 100644 --- a/src/duckdb/src/common/enum_util.cpp +++ b/src/duckdb/src/common/enum_util.cpp @@ -98,6 +98,7 @@ #include "duckdb/function/table/arrow/enum/arrow_type_info_type.hpp" #include "duckdb/function/table/arrow/enum/arrow_variable_size_type.hpp" #include "duckdb/function/table_function.hpp" +#include "duckdb/logging/logging.hpp" #include "duckdb/main/appender.hpp" #include "duckdb/main/capi/capi_internal.hpp" #include "duckdb/main/client_properties.hpp" @@ -2043,6 +2044,66 @@ LoadType EnumUtil::FromString(const char *value) { return static_cast(StringUtil::StringToEnum(GetLoadTypeValues(), 3, "LoadType", value)); } +const StringUtil::EnumStringLiteral *GetLogContextScopeValues() { + static constexpr StringUtil::EnumStringLiteral values[] { + { static_cast(LogContextScope::DATABASE), "DATABASE" }, + { static_cast(LogContextScope::CONNECTION), "CONNECTION" }, + { static_cast(LogContextScope::THREAD), "THREAD" } + }; + return values; +} + +template<> +const char* EnumUtil::ToChars(LogContextScope value) { + return StringUtil::EnumToString(GetLogContextScopeValues(), 3, "LogContextScope", static_cast(value)); +} + +template<> +LogContextScope EnumUtil::FromString(const char *value) { + return static_cast(StringUtil::StringToEnum(GetLogContextScopeValues(), 3, "LogContextScope", value)); +} + +const StringUtil::EnumStringLiteral *GetLogLevelValues() { + static constexpr StringUtil::EnumStringLiteral values[] { + { static_cast(LogLevel::LOG_TRACE), "TRACE" }, + { static_cast(LogLevel::LOG_DEBUG), "DEBUG" }, + { static_cast(LogLevel::LOG_INFO), "INFO" }, + { static_cast(LogLevel::LOG_WARN), "WARN" }, + { static_cast(LogLevel::LOG_ERROR), "ERROR" }, + { static_cast(LogLevel::LOG_FATAL), "FATAL" } + }; + return values; +} + +template<> +const char* EnumUtil::ToChars(LogLevel value) { + return StringUtil::EnumToString(GetLogLevelValues(), 6, "LogLevel", static_cast(value)); +} + +template<> +LogLevel EnumUtil::FromString(const char *value) { + return static_cast(StringUtil::StringToEnum(GetLogLevelValues(), 6, "LogLevel", value)); +} + +const StringUtil::EnumStringLiteral *GetLogModeValues() { + static constexpr StringUtil::EnumStringLiteral values[] { + { static_cast(LogMode::LEVEL_ONLY), "LEVEL_ONLY" }, + { static_cast(LogMode::DISABLE_SELECTED), "DISABLE_SELECTED" }, + { static_cast(LogMode::ENABLE_SELECTED), "ENABLE_SELECTED" } + }; + return values; +} + +template<> +const char* EnumUtil::ToChars(LogMode value) { + return StringUtil::EnumToString(GetLogModeValues(), 3, "LogMode", static_cast(value)); +} + +template<> +LogMode EnumUtil::FromString(const char *value) { + return static_cast(StringUtil::StringToEnum(GetLogModeValues(), 3, "LogMode", value)); +} + const StringUtil::EnumStringLiteral *GetLogicalOperatorTypeValues() { static constexpr StringUtil::EnumStringLiteral values[] { { static_cast(LogicalOperatorType::LOGICAL_INVALID), "LOGICAL_INVALID" }, diff --git a/src/duckdb/src/common/local_file_system.cpp b/src/duckdb/src/common/local_file_system.cpp index 83e242526..7136dc715 100644 --- a/src/duckdb/src/common/local_file_system.cpp +++ b/src/duckdb/src/common/local_file_system.cpp @@ -301,6 +301,10 @@ unique_ptr LocalFileSystem::OpenFile(const string &path_p, FileOpenF throw NotImplementedException("Unsupported compression type for default file system"); } + if (opener) { + Logger::Info("duckdb.FileSystem.LocalFileSystem.OpenFile", *opener, path_p); + } + flags.Verify(); int open_flags = 0; @@ -837,6 +841,10 @@ unique_ptr LocalFileSystem::OpenFile(const string &path_p, FileOpenF } flags.Verify(); + if (opener) { + Logger::Info("duckdb.FileSystem.LocalFileSystem.OpenFile", *opener, path_p); + } + DWORD desired_access; DWORD share_mode; DWORD creation_disposition = OPEN_EXISTING; diff --git a/src/duckdb/src/function/function_list.cpp b/src/duckdb/src/function/function_list.cpp index 70d869703..3950308e3 100644 --- a/src/duckdb/src/function/function_list.cpp +++ b/src/duckdb/src/function/function_list.cpp @@ -163,6 +163,7 @@ static const StaticFunctionDefinition function[] = { DUCKDB_SCALAR_FUNCTION_SET(TryStrpTimeFun), DUCKDB_SCALAR_FUNCTION_ALIAS(UcaseFun), DUCKDB_SCALAR_FUNCTION(UpperFun), + DUCKDB_SCALAR_FUNCTION_SET(WriteLogFun), DUCKDB_SCALAR_FUNCTION(ConcatOperatorFun), DUCKDB_SCALAR_FUNCTION(LikeFun), DUCKDB_SCALAR_FUNCTION(ILikeFun), diff --git a/src/duckdb/src/function/scalar/system/write_log.cpp b/src/duckdb/src/function/scalar/system/write_log.cpp new file mode 100644 index 000000000..51c914564 --- /dev/null +++ b/src/duckdb/src/function/scalar/system/write_log.cpp @@ -0,0 +1,170 @@ +#include "duckdb/function/scalar/system_functions.hpp" +#include "duckdb/execution/expression_executor.hpp" +#include "duckdb/main/client_data.hpp" +#include "duckdb/planner/expression/bound_function_expression.hpp" + +#include "utf8proc.hpp" + +namespace duckdb { + +struct WriteLogBindData : FunctionData { + //! Config + bool disable_logging = false; + string scope; + LogLevel level = LogLevel::LOG_INFO; + string type; + + //! Context + optional_ptr context; + + //! Output + idx_t output_col = DConstants::INVALID_INDEX; + LogicalType return_type; + + explicit WriteLogBindData() {}; + WriteLogBindData(const WriteLogBindData &other) { + disable_logging = other.disable_logging; + scope = other.scope; + level = other.level; + type = other.type; + + context = other.context; + + output_col = other.output_col; + return_type = other.return_type; + } + +public: + unique_ptr Copy() const override { + return make_uniq(*this); + } + bool Equals(const FunctionData &other_p) const override { + return true; + } +}; + +static void ThrowIfNotConstant(const Expression &arg) { + if (!arg.IsFoldable()) { + throw BinderException("write_log: argument '%s' must be constant", arg.alias); + } +} + +unique_ptr WriteLogBind(ClientContext &context, ScalarFunction &bound_function, + vector> &arguments) { + if (arguments.empty()) { + throw BinderException("write_log takes at least one argument"); + } + + if (arguments[0]->return_type != LogicalType::VARCHAR) { + throw InvalidTypeException("write_log first argument must be a VARCHAR"); + } + + // Used to replace the actual log call with a nop: useful for benchmarking + auto result = make_uniq(); + + // Default return type + bound_function.return_type = LogicalType::VARCHAR; + + for (idx_t i = 1; i < arguments.size(); i++) { + auto &arg = arguments[i]; + if (arg->HasParameter()) { + throw ParameterNotResolvedException(); + } + if (arg->alias == "disable_logging") { + ThrowIfNotConstant(*arg); + if (arg->return_type.id() != LogicalTypeId::BOOLEAN) { + throw BinderException("write_log: 'disable_logging' argument must be a boolean"); + } + result->disable_logging = BooleanValue::Get(ExpressionExecutor::EvaluateScalar(context, *arg)); + } else if (arg->alias == "scope") { + ThrowIfNotConstant(*arg); + if (arg->return_type.id() != LogicalTypeId::VARCHAR) { + throw BinderException("write_log: 'scope' argument must be a string"); + } + result->scope = StringValue::Get(ExpressionExecutor::EvaluateScalar(context, *arg)); + } else if (arg->alias == "level") { + ThrowIfNotConstant(*arg); + if (arg->return_type.id() != LogicalTypeId::VARCHAR) { + throw BinderException("write_log: 'level' argument must be a string"); + } + result->level = + EnumUtil::FromString(StringValue::Get(ExpressionExecutor::EvaluateScalar(context, *arg))); + } else if (arg->alias == "log_type") { + ThrowIfNotConstant(*arg); + if (arg->return_type.id() != LogicalTypeId::VARCHAR) { + throw BinderException("write_log: 'log_type' argument must be a string"); + } + result->type = StringValue::Get(ExpressionExecutor::EvaluateScalar(context, *arg)); + } else if (arg->alias == "return_value") { + result->return_type = arg->return_type; + result->output_col = i; + bound_function.return_type = result->return_type; + } else { + throw BinderException(StringUtil::Format("write_log: Unknown argument '%s'", arg->alias)); + } + } + + result->context = context; + + return std::move(result); +} + +template +static void WriteLogValues(T &LogSource, LogLevel level, const string_t *data, const SelectionVector *sel, idx_t size, + const string &type) { + if (!type.empty()) { + for (idx_t i = 0; i < size; i++) { + Logger::Log(type.c_str(), LogSource, level, data[sel->get_index(i)]); + } + } else { + for (idx_t i = 0; i < size; i++) { + Logger::Log(LogSource, level, data[sel->get_index(i)]); + } + } +} + +static void WriteLogFunction(DataChunk &args, ExpressionState &state, Vector &result) { + D_ASSERT(args.ColumnCount() >= 1); + + auto &func_expr = state.expr.Cast(); + const auto &info = func_expr.bind_info->Cast(); + + UnifiedVectorFormat idata; + args.data[0].ToUnifiedFormat(args.size(), idata); + + auto input_data = UnifiedVectorFormat::GetData(idata); + + if (!info.disable_logging) { + if (info.scope.empty() || info.scope == "connection") { + WriteLogValues(*info.context, info.level, input_data, idata.sel, args.size(), + info.type); + } else if (info.scope == "database") { + WriteLogValues(*info.context->db, info.level, input_data, idata.sel, args.size(), + info.type); + } else if (info.scope == "file_opener") { + WriteLogValues(*info.context->client_data->file_opener, info.level, input_data, idata.sel, + args.size(), info.type); + } else { + throw InvalidInputException( + "write_log: 'scope' argument unknown: '%s'. Valid values are [connection, database, file_opener]", + info.scope); + } + } + + if (info.output_col != DConstants::INVALID_INDEX) { + result.Reference(args.data[info.output_col]); + } else { + result.Reference(Value(LogicalType::VARCHAR)); + } +} + +ScalarFunctionSet WriteLogFun::GetFunctions() { + ScalarFunctionSet set("write_log"); + + set.AddFunction(ScalarFunction({LogicalType::VARCHAR}, LogicalType::ANY, WriteLogFunction, WriteLogBind, nullptr, + nullptr, nullptr, LogicalType::ANY, FunctionStability::VOLATILE)); + + return set; +} + +} // namespace duckdb diff --git a/src/duckdb/src/function/table/arrow.cpp b/src/duckdb/src/function/table/arrow.cpp index 5d719e8f7..9d9fd2296 100644 --- a/src/duckdb/src/function/table/arrow.cpp +++ b/src/duckdb/src/function/table/arrow.cpp @@ -17,349 +17,15 @@ namespace duckdb { -static unique_ptr CreateListType(ArrowSchema &child, ArrowVariableSizeType size_type, bool view) { - auto child_type = ArrowTableFunction::GetArrowLogicalType(child); - - unique_ptr type_info; - auto type = LogicalType::LIST(child_type->GetDuckType()); - if (view) { - type_info = ArrowListInfo::ListView(std::move(child_type), size_type); - } else { - type_info = ArrowListInfo::List(std::move(child_type), size_type); - } - return make_uniq(type, std::move(type_info)); -} - -static unique_ptr GetArrowExtensionType(const ArrowSchemaMetadata &extension_type, const string &format) { - auto arrow_extension = extension_type.GetExtensionName(); - // Check for arrow canonical extensions - if (arrow_extension == "arrow.uuid") { - if (format != "w:16") { - std::ostringstream error; - error - << "arrow.uuid must be a fixed-size binary of 16 bytes (i.e., \'w:16\'). It is incorrectly defined as:" - << format; - return make_uniq(error.str()); - } - return make_uniq(LogicalType::UUID); - } else if (arrow_extension == "arrow.json") { - if (format == "u") { - return make_uniq(LogicalType::JSON(), make_uniq(ArrowVariableSizeType::NORMAL)); - } else if (format == "U") { - return make_uniq(LogicalType::JSON(), - make_uniq(ArrowVariableSizeType::SUPER_SIZE)); - } else if (format == "vu") { - return make_uniq(LogicalType::JSON(), make_uniq(ArrowVariableSizeType::VIEW)); - } else { - std::ostringstream error; - error - << "arrow.json must be of a varchar format (i.e., \'u\',\'U\' or \'vu\'). It is incorrectly defined as:" - << format; - return make_uniq(error.str()); - } - } - // Check for DuckDB canonical extensions - else if (extension_type.IsNonCanonicalType("hugeint")) { - if (format != "w:16") { - std::ostringstream error; - error << "DuckDB hugeint must be a fixed-size binary of 16 bytes (i.e., \'w:16\'). It is incorrectly " - "defined as:" - << format; - return make_uniq(error.str()); - } - return make_uniq(LogicalType::HUGEINT); - } else if (extension_type.IsNonCanonicalType("uhugeint")) { - if (format != "w:16") { - std::ostringstream error; - error << "DuckDB uhugeint must be a fixed-size binary of 16 bytes (i.e., \'w:16\'). It is incorrectly " - "defined as:" - << format; - return make_uniq(error.str()); - } - return make_uniq(LogicalType::UHUGEINT); - } else if (extension_type.IsNonCanonicalType("time_tz")) { - if (format != "w:8") { - std::ostringstream error; - error << "DuckDB time_tz must be a fixed-size binary of 8 bytes (i.e., \'w:8\'). It is incorrectly defined " - "as:" - << format; - return make_uniq(error.str()); - } - return make_uniq(LogicalType::TIME_TZ, - make_uniq(ArrowDateTimeType::MICROSECONDS)); - } else if (extension_type.IsNonCanonicalType("bit")) { - if (format != "z" && format != "Z") { - std::ostringstream error; - error << "DuckDB bit must be a blob (i.e., \'z\' or \'Z\'). It is incorrectly defined as:" << format; - return make_uniq(error.str()); - } else if (format == "z") { - auto type_info = make_uniq(ArrowVariableSizeType::NORMAL); - return make_uniq(LogicalType::BIT, std::move(type_info)); - } - auto type_info = make_uniq(ArrowVariableSizeType::SUPER_SIZE); - return make_uniq(LogicalType::BIT, std::move(type_info)); - - } else if (extension_type.IsNonCanonicalType("varint")) { - if (format != "z" && format != "Z") { - std::ostringstream error; - error << "DuckDB bit must be a blob (i.e., \'z\'). It is incorrectly defined as:" << format; - return make_uniq(error.str()); - } - unique_ptr type_info; - if (format == "z") { - type_info = make_uniq(ArrowVariableSizeType::NORMAL); - } else { - type_info = make_uniq(ArrowVariableSizeType::SUPER_SIZE); - } - return make_uniq(LogicalType::VARINT, std::move(type_info)); - } else { - std::ostringstream error; - error << "Arrow Type with extension name: " << arrow_extension << " and format: " << format - << ", is not currently supported in DuckDB."; - return make_uniq(error.str(), true); - } -} -static unique_ptr GetArrowLogicalTypeNoDictionary(ArrowSchema &schema) { - auto format = string(schema.format); - // Let's first figure out if this type is an extension type - ArrowSchemaMetadata schema_metadata(schema.metadata); - if (schema_metadata.HasExtension()) { - return GetArrowExtensionType(schema_metadata, format); - } - // If not, we just check the format itself - if (format == "n") { - return make_uniq(LogicalType::SQLNULL); - } else if (format == "b") { - return make_uniq(LogicalType::BOOLEAN); - } else if (format == "c") { - return make_uniq(LogicalType::TINYINT); - } else if (format == "s") { - return make_uniq(LogicalType::SMALLINT); - } else if (format == "i") { - return make_uniq(LogicalType::INTEGER); - } else if (format == "l") { - return make_uniq(LogicalType::BIGINT); - } else if (format == "C") { - return make_uniq(LogicalType::UTINYINT); - } else if (format == "S") { - return make_uniq(LogicalType::USMALLINT); - } else if (format == "I") { - return make_uniq(LogicalType::UINTEGER); - } else if (format == "L") { - return make_uniq(LogicalType::UBIGINT); - } else if (format == "f") { - return make_uniq(LogicalType::FLOAT); - } else if (format == "g") { - return make_uniq(LogicalType::DOUBLE); - } else if (format[0] == 'd') { //! this can be either decimal128 or decimal 256 (e.g., d:38,0) - auto extra_info = StringUtil::Split(format, ':'); - if (extra_info.size() != 2) { - throw InvalidInputException( - "Decimal format of Arrow object is incomplete, it is missing the scale and width. Current format: %s", - format); - } - auto parameters = StringUtil::Split(extra_info[1], ","); - // Parameters must always be 2 or 3 values (i.e., width, scale and an optional bit-width) - if (parameters.size() != 2 && parameters.size() != 3) { - throw InvalidInputException( - "Decimal format of Arrow object is incomplete, it is missing the scale or width. Current format: %s", - format); - } - uint64_t width = std::stoull(parameters[0]); - uint64_t scale = std::stoull(parameters[1]); - uint64_t bitwidth = 128; - if (parameters.size() == 3) { - // We have a bit-width defined - bitwidth = std::stoull(parameters[2]); - } - if (width > 38 || bitwidth > 128) { - throw NotImplementedException("Unsupported Internal Arrow Type for Decimal %s", format); - } - return make_uniq(LogicalType::DECIMAL(NumericCast(width), NumericCast(scale))); - } else if (format == "u") { - return make_uniq(LogicalType::VARCHAR, make_uniq(ArrowVariableSizeType::NORMAL)); - } else if (format == "U") { - return make_uniq(LogicalType::VARCHAR, - make_uniq(ArrowVariableSizeType::SUPER_SIZE)); - } else if (format == "vu") { - return make_uniq(LogicalType::VARCHAR, make_uniq(ArrowVariableSizeType::VIEW)); - } else if (format == "tsn:") { - return make_uniq(LogicalTypeId::TIMESTAMP_NS); - } else if (format == "tsu:") { - return make_uniq(LogicalTypeId::TIMESTAMP); - } else if (format == "tsm:") { - return make_uniq(LogicalTypeId::TIMESTAMP_MS); - } else if (format == "tss:") { - return make_uniq(LogicalTypeId::TIMESTAMP_SEC); - } else if (format == "tdD") { - return make_uniq(LogicalType::DATE, make_uniq(ArrowDateTimeType::DAYS)); - } else if (format == "tdm") { - return make_uniq(LogicalType::DATE, make_uniq(ArrowDateTimeType::MILLISECONDS)); - } else if (format == "tts") { - return make_uniq(LogicalType::TIME, make_uniq(ArrowDateTimeType::SECONDS)); - } else if (format == "ttm") { - return make_uniq(LogicalType::TIME, make_uniq(ArrowDateTimeType::MILLISECONDS)); - } else if (format == "ttu") { - return make_uniq(LogicalType::TIME, make_uniq(ArrowDateTimeType::MICROSECONDS)); - } else if (format == "ttn") { - return make_uniq(LogicalType::TIME, make_uniq(ArrowDateTimeType::NANOSECONDS)); - } else if (format == "tDs") { - return make_uniq(LogicalType::INTERVAL, make_uniq(ArrowDateTimeType::SECONDS)); - } else if (format == "tDm") { - return make_uniq(LogicalType::INTERVAL, - make_uniq(ArrowDateTimeType::MILLISECONDS)); - } else if (format == "tDu") { - return make_uniq(LogicalType::INTERVAL, - make_uniq(ArrowDateTimeType::MICROSECONDS)); - } else if (format == "tDn") { - return make_uniq(LogicalType::INTERVAL, - make_uniq(ArrowDateTimeType::NANOSECONDS)); - } else if (format == "tiD") { - return make_uniq(LogicalType::INTERVAL, make_uniq(ArrowDateTimeType::DAYS)); - } else if (format == "tiM") { - return make_uniq(LogicalType::INTERVAL, make_uniq(ArrowDateTimeType::MONTHS)); - } else if (format == "tin") { - return make_uniq(LogicalType::INTERVAL, - make_uniq(ArrowDateTimeType::MONTH_DAY_NANO)); - } else if (format == "+l") { - return CreateListType(*schema.children[0], ArrowVariableSizeType::NORMAL, false); - } else if (format == "+L") { - return CreateListType(*schema.children[0], ArrowVariableSizeType::SUPER_SIZE, false); - } else if (format == "+vl") { - return CreateListType(*schema.children[0], ArrowVariableSizeType::NORMAL, true); - } else if (format == "+vL") { - return CreateListType(*schema.children[0], ArrowVariableSizeType::SUPER_SIZE, true); - } else if (format[0] == '+' && format[1] == 'w') { - std::string parameters = format.substr(format.find(':') + 1); - auto fixed_size = NumericCast(std::stoi(parameters)); - auto child_type = ArrowTableFunction::GetArrowLogicalType(*schema.children[0]); - - auto array_type = LogicalType::ARRAY(child_type->GetDuckType(), fixed_size); - auto type_info = make_uniq(std::move(child_type), fixed_size); - return make_uniq(array_type, std::move(type_info)); - } else if (format == "+s") { - child_list_t child_types; - vector> children; - if (schema.n_children == 0) { - throw InvalidInputException( - "Attempted to convert a STRUCT with no fields to DuckDB which is not supported"); - } - for (idx_t type_idx = 0; type_idx < (idx_t)schema.n_children; type_idx++) { - children.emplace_back(ArrowTableFunction::GetArrowLogicalType(*schema.children[type_idx])); - child_types.emplace_back(schema.children[type_idx]->name, children.back()->GetDuckType()); - } - auto type_info = make_uniq(std::move(children)); - auto struct_type = make_uniq(LogicalType::STRUCT(std::move(child_types)), std::move(type_info)); - return struct_type; - } else if (format[0] == '+' && format[1] == 'u') { - if (format[2] != 's') { - throw NotImplementedException("Unsupported Internal Arrow Type: \"%c\" Union", format[2]); - } - D_ASSERT(format[3] == ':'); - - std::string prefix = "+us:"; - // TODO: what are these type ids actually for? - auto type_ids = StringUtil::Split(format.substr(prefix.size()), ','); - - child_list_t members; - vector> children; - if (schema.n_children == 0) { - throw InvalidInputException("Attempted to convert a UNION with no fields to DuckDB which is not supported"); - } - for (idx_t type_idx = 0; type_idx < (idx_t)schema.n_children; type_idx++) { - auto type = schema.children[type_idx]; - - children.emplace_back(ArrowTableFunction::GetArrowLogicalType(*type)); - members.emplace_back(type->name, children.back()->GetDuckType()); - } - - auto type_info = make_uniq(std::move(children)); - auto union_type = make_uniq(LogicalType::UNION(members), std::move(type_info)); - return union_type; - } else if (format == "+r") { - child_list_t members; - vector> children; - idx_t n_children = idx_t(schema.n_children); - D_ASSERT(n_children == 2); - D_ASSERT(string(schema.children[0]->name) == "run_ends"); - D_ASSERT(string(schema.children[1]->name) == "values"); - for (idx_t i = 0; i < n_children; i++) { - auto type = schema.children[i]; - children.emplace_back(ArrowTableFunction::GetArrowLogicalType(*type)); - members.emplace_back(type->name, children.back()->GetDuckType()); - } - - auto type_info = make_uniq(std::move(children)); - auto struct_type = make_uniq(LogicalType::STRUCT(members), std::move(type_info)); - struct_type->SetRunEndEncoded(); - return struct_type; - } else if (format == "+m") { - auto &arrow_struct_type = *schema.children[0]; - D_ASSERT(arrow_struct_type.n_children == 2); - auto key_type = ArrowTableFunction::GetArrowLogicalType(*arrow_struct_type.children[0]); - auto value_type = ArrowTableFunction::GetArrowLogicalType(*arrow_struct_type.children[1]); - child_list_t key_value; - key_value.emplace_back(std::make_pair("key", key_type->GetDuckType())); - key_value.emplace_back(std::make_pair("value", value_type->GetDuckType())); - - auto map_type = LogicalType::MAP(key_type->GetDuckType(), value_type->GetDuckType()); - vector> children; - children.reserve(2); - children.push_back(std::move(key_type)); - children.push_back(std::move(value_type)); - auto inner_struct = make_uniq(LogicalType::STRUCT(std::move(key_value)), - make_uniq(std::move(children))); - auto map_type_info = ArrowListInfo::List(std::move(inner_struct), ArrowVariableSizeType::NORMAL); - return make_uniq(map_type, std::move(map_type_info)); - } else if (format == "z") { - auto type_info = make_uniq(ArrowVariableSizeType::NORMAL); - return make_uniq(LogicalType::BLOB, std::move(type_info)); - } else if (format == "Z") { - auto type_info = make_uniq(ArrowVariableSizeType::SUPER_SIZE); - return make_uniq(LogicalType::BLOB, std::move(type_info)); - } else if (format[0] == 'w') { - string parameters = format.substr(format.find(':') + 1); - auto fixed_size = NumericCast(std::stoi(parameters)); - auto type_info = make_uniq(fixed_size); - return make_uniq(LogicalType::BLOB, std::move(type_info)); - } else if (format[0] == 't' && format[1] == 's') { - // Timestamp with Timezone - // TODO right now we just get the UTC value. We probably want to support this properly in the future - unique_ptr type_info; - if (format[2] == 'n') { - type_info = make_uniq(ArrowDateTimeType::NANOSECONDS); - } else if (format[2] == 'u') { - type_info = make_uniq(ArrowDateTimeType::MICROSECONDS); - } else if (format[2] == 'm') { - type_info = make_uniq(ArrowDateTimeType::MILLISECONDS); - } else if (format[2] == 's') { - type_info = make_uniq(ArrowDateTimeType::SECONDS); - } else { - throw NotImplementedException(" Timestamptz precision of not accepted"); - } - return make_uniq(LogicalType::TIMESTAMP_TZ, std::move(type_info)); - } else { - throw NotImplementedException("Unsupported Internal Arrow Type %s", format); - } -} - -unique_ptr ArrowTableFunction::GetArrowLogicalType(ArrowSchema &schema) { - auto arrow_type = GetArrowLogicalTypeNoDictionary(schema); - if (schema.dictionary) { - auto dictionary = GetArrowLogicalType(*schema.dictionary); - arrow_type->SetDictionary(std::move(dictionary)); - } - return arrow_type; -} - -void ArrowTableFunction::PopulateArrowTableType(ArrowTableType &arrow_table, ArrowSchemaWrapper &schema_p, - vector &names, vector &return_types) { - for (idx_t col_idx = 0; col_idx < (idx_t)schema_p.arrow_schema.n_children; col_idx++) { +void ArrowTableFunction::PopulateArrowTableType(DBConfig &config, ArrowTableType &arrow_table, + const ArrowSchemaWrapper &schema_p, vector &names, + vector &return_types) { + for (idx_t col_idx = 0; col_idx < static_cast(schema_p.arrow_schema.n_children); col_idx++) { auto &schema = *schema_p.arrow_schema.children[col_idx]; if (!schema.release) { throw InvalidInputException("arrow_scan: released schema passed"); } - auto arrow_type = GetArrowLogicalType(schema); + auto arrow_type = ArrowType::GetArrowLogicalType(config, schema); return_types.emplace_back(arrow_type->GetDuckType(true)); arrow_table.AddColumn(col_idx, std::move(arrow_type)); auto name = string(schema.name); @@ -402,7 +68,7 @@ unique_ptr ArrowTableFunction::ArrowScanBind(ClientContext &contex auto &data = *res; stream_factory_get_schema(reinterpret_cast(stream_factory_ptr), data.schema_root.arrow_schema); - PopulateArrowTableType(res->arrow_table, data.schema_root, names, return_types); + PopulateArrowTableType(DBConfig::GetConfig(context), res->arrow_table, data.schema_root, names, return_types); QueryResult::DeduplicateColumns(names); res->all_types = return_types; if (return_types.empty()) { @@ -481,7 +147,7 @@ ArrowTableFunction::ArrowScanInitLocalInternal(ClientContext &context, TableFunc GlobalTableFunctionState *global_state_p) { auto &global_state = global_state_p->Cast(); auto current_chunk = make_uniq(); - auto result = make_uniq(std::move(current_chunk)); + auto result = make_uniq(std::move(current_chunk), context); result->column_ids = input.column_ids; result->filters = input.filters.get(); auto &bind_data = input.bind_data->Cast(); @@ -512,7 +178,7 @@ void ArrowTableFunction::ArrowScanFunction(ClientContext &context, TableFunction auto &global_state = data_p.global_state->Cast(); //! Out of tuples in this chunk - if (state.chunk_offset >= (idx_t)state.chunk->arrow_array.length) { + if (state.chunk_offset >= static_cast(state.chunk->arrow_array.length)) { if (!ArrowScanParallelStateNext(context, data_p.bind_data.get(), state, global_state)) { return; } @@ -579,7 +245,7 @@ bool ArrowTableFunction::ArrowPushdownType(const LogicalType &type) { default: return false; } - } break; + } case LogicalTypeId::STRUCT: { auto struct_types = StructType::GetChildTypes(type); for (auto &struct_type : struct_types) { diff --git a/src/duckdb/src/function/table/arrow/arrow_array_scan_state.cpp b/src/duckdb/src/function/table/arrow/arrow_array_scan_state.cpp index 749ebc29c..bbb1bf3e2 100644 --- a/src/duckdb/src/function/table/arrow/arrow_array_scan_state.cpp +++ b/src/duckdb/src/function/table/arrow/arrow_array_scan_state.cpp @@ -4,14 +4,15 @@ namespace duckdb { -ArrowArrayScanState::ArrowArrayScanState(ArrowScanLocalState &state) : state(state) { +ArrowArrayScanState::ArrowArrayScanState(ArrowScanLocalState &state, ClientContext &context) + : state(state), context(context) { arrow_dictionary = nullptr; } ArrowArrayScanState &ArrowArrayScanState::GetChild(idx_t child_idx) { auto it = children.find(child_idx); if (it == children.end()) { - auto child_p = make_uniq(state); + auto child_p = make_uniq(state, context); auto &child = *child_p; child.owned_data = owned_data; children.emplace(child_idx, std::move(child_p)); diff --git a/src/duckdb/src/function/table/arrow/arrow_duck_schema.cpp b/src/duckdb/src/function/table/arrow/arrow_duck_schema.cpp index 3f23e94ee..a3245efff 100644 --- a/src/duckdb/src/function/table/arrow/arrow_duck_schema.cpp +++ b/src/duckdb/src/function/table/arrow/arrow_duck_schema.cpp @@ -2,9 +2,13 @@ #include "duckdb/common/arrow/arrow.hpp" #include "duckdb/common/exception.hpp" +#include "duckdb/common/string_util.hpp" +#include "duckdb/common/arrow/schema_metadata.hpp" +#include "duckdb/main/config.hpp" + namespace duckdb { -void ArrowTableType::AddColumn(idx_t index, unique_ptr type) { +void ArrowTableType::AddColumn(idx_t index, shared_ptr type) { D_ASSERT(arrow_convert_data.find(index) == arrow_convert_data.end()); arrow_convert_data.emplace(std::make_pair(index, std::move(type))); } @@ -52,11 +56,245 @@ void ArrowType::ThrowIfInvalid() const { } } +unique_ptr ArrowType::GetTypeFromFormat(DBConfig &config, ArrowSchema &schema, string &format) { + if (format == "n") { + return make_uniq(LogicalType::SQLNULL); + } else if (format == "b") { + return make_uniq(LogicalType::BOOLEAN); + } else if (format == "c") { + return make_uniq(LogicalType::TINYINT); + } else if (format == "s") { + return make_uniq(LogicalType::SMALLINT); + } else if (format == "i") { + return make_uniq(LogicalType::INTEGER); + } else if (format == "l") { + return make_uniq(LogicalType::BIGINT); + } else if (format == "C") { + return make_uniq(LogicalType::UTINYINT); + } else if (format == "S") { + return make_uniq(LogicalType::USMALLINT); + } else if (format == "I") { + return make_uniq(LogicalType::UINTEGER); + } else if (format == "L") { + return make_uniq(LogicalType::UBIGINT); + } else if (format == "f") { + return make_uniq(LogicalType::FLOAT); + } else if (format == "g") { + return make_uniq(LogicalType::DOUBLE); + } else if (format[0] == 'd') { //! this can be either decimal128 or decimal 256 (e.g., d:38,0) + auto extra_info = StringUtil::Split(format, ':'); + if (extra_info.size() != 2) { + throw InvalidInputException( + "Decimal format of Arrow object is incomplete, it is missing the scale and width. Current format: %s", + format); + } + auto parameters = StringUtil::Split(extra_info[1], ","); + // Parameters must always be 2 or 3 values (i.e., width, scale and an optional bit-width) + if (parameters.size() != 2 && parameters.size() != 3) { + throw InvalidInputException( + "Decimal format of Arrow object is incomplete, it is missing the scale or width. Current format: %s", + format); + } + uint64_t width = std::stoull(parameters[0]); + uint64_t scale = std::stoull(parameters[1]); + uint64_t bitwidth = 128; + if (parameters.size() == 3) { + // We have a bit-width defined + bitwidth = std::stoull(parameters[2]); + } + if (width > 38 || bitwidth > 128) { + throw NotImplementedException("Unsupported Internal Arrow Type for Decimal %s", format); + } + return make_uniq(LogicalType::DECIMAL(NumericCast(width), NumericCast(scale))); + } else if (format == "u") { + return make_uniq(LogicalType::VARCHAR, make_uniq(ArrowVariableSizeType::NORMAL)); + } else if (format == "U") { + return make_uniq(LogicalType::VARCHAR, + make_uniq(ArrowVariableSizeType::SUPER_SIZE)); + } else if (format == "vu") { + return make_uniq(LogicalType::VARCHAR, make_uniq(ArrowVariableSizeType::VIEW)); + } else if (format == "tsn:") { + return make_uniq(LogicalTypeId::TIMESTAMP_NS); + } else if (format == "tsu:") { + return make_uniq(LogicalTypeId::TIMESTAMP); + } else if (format == "tsm:") { + return make_uniq(LogicalTypeId::TIMESTAMP_MS); + } else if (format == "tss:") { + return make_uniq(LogicalTypeId::TIMESTAMP_SEC); + } else if (format == "tdD") { + return make_uniq(LogicalType::DATE, make_uniq(ArrowDateTimeType::DAYS)); + } else if (format == "tdm") { + return make_uniq(LogicalType::DATE, make_uniq(ArrowDateTimeType::MILLISECONDS)); + } else if (format == "tts") { + return make_uniq(LogicalType::TIME, make_uniq(ArrowDateTimeType::SECONDS)); + } else if (format == "ttm") { + return make_uniq(LogicalType::TIME, make_uniq(ArrowDateTimeType::MILLISECONDS)); + } else if (format == "ttu") { + return make_uniq(LogicalType::TIME, make_uniq(ArrowDateTimeType::MICROSECONDS)); + } else if (format == "ttn") { + return make_uniq(LogicalType::TIME, make_uniq(ArrowDateTimeType::NANOSECONDS)); + } else if (format == "tDs") { + return make_uniq(LogicalType::INTERVAL, make_uniq(ArrowDateTimeType::SECONDS)); + } else if (format == "tDm") { + return make_uniq(LogicalType::INTERVAL, + make_uniq(ArrowDateTimeType::MILLISECONDS)); + } else if (format == "tDu") { + return make_uniq(LogicalType::INTERVAL, + make_uniq(ArrowDateTimeType::MICROSECONDS)); + } else if (format == "tDn") { + return make_uniq(LogicalType::INTERVAL, + make_uniq(ArrowDateTimeType::NANOSECONDS)); + } else if (format == "tiD") { + return make_uniq(LogicalType::INTERVAL, make_uniq(ArrowDateTimeType::DAYS)); + } else if (format == "tiM") { + return make_uniq(LogicalType::INTERVAL, make_uniq(ArrowDateTimeType::MONTHS)); + } else if (format == "tin") { + return make_uniq(LogicalType::INTERVAL, + make_uniq(ArrowDateTimeType::MONTH_DAY_NANO)); + } else if (format == "z") { + auto type_info = make_uniq(ArrowVariableSizeType::NORMAL); + return make_uniq(LogicalType::BLOB, std::move(type_info)); + } else if (format == "Z") { + auto type_info = make_uniq(ArrowVariableSizeType::SUPER_SIZE); + return make_uniq(LogicalType::BLOB, std::move(type_info)); + } else if (format[0] == 'w') { + string parameters = format.substr(format.find(':') + 1); + auto fixed_size = NumericCast(std::stoi(parameters)); + auto type_info = make_uniq(fixed_size); + return make_uniq(LogicalType::BLOB, std::move(type_info)); + } else if (format[0] == 't' && format[1] == 's') { + // Timestamp with Timezone + // TODO right now we just get the UTC value. We probably want to support this properly in the future + unique_ptr type_info; + if (format[2] == 'n') { + type_info = make_uniq(ArrowDateTimeType::NANOSECONDS); + } else if (format[2] == 'u') { + type_info = make_uniq(ArrowDateTimeType::MICROSECONDS); + } else if (format[2] == 'm') { + type_info = make_uniq(ArrowDateTimeType::MILLISECONDS); + } else if (format[2] == 's') { + type_info = make_uniq(ArrowDateTimeType::SECONDS); + } else { + throw NotImplementedException(" Timestamptz precision of not accepted"); + } + return make_uniq(LogicalType::TIMESTAMP_TZ, std::move(type_info)); + } + if (format == "+l") { + return CreateListType(config, *schema.children[0], ArrowVariableSizeType::NORMAL, false); + } else if (format == "+L") { + return CreateListType(config, *schema.children[0], ArrowVariableSizeType::SUPER_SIZE, false); + } else if (format == "+vl") { + return CreateListType(config, *schema.children[0], ArrowVariableSizeType::NORMAL, true); + } else if (format == "+vL") { + return CreateListType(config, *schema.children[0], ArrowVariableSizeType::SUPER_SIZE, true); + } else if (format[0] == '+' && format[1] == 'w') { + std::string parameters = format.substr(format.find(':') + 1); + auto fixed_size = NumericCast(std::stoi(parameters)); + auto child_type = GetArrowLogicalType(config, *schema.children[0]); + + auto array_type = LogicalType::ARRAY(child_type->GetDuckType(), fixed_size); + auto type_info = make_uniq(std::move(child_type), fixed_size); + return make_uniq(array_type, std::move(type_info)); + } else if (format == "+s") { + child_list_t child_types; + vector> children; + if (schema.n_children == 0) { + throw InvalidInputException( + "Attempted to convert a STRUCT with no fields to DuckDB which is not supported"); + } + for (idx_t type_idx = 0; type_idx < static_cast(schema.n_children); type_idx++) { + children.emplace_back(GetArrowLogicalType(config, *schema.children[type_idx])); + child_types.emplace_back(schema.children[type_idx]->name, children.back()->GetDuckType()); + } + auto type_info = make_uniq(std::move(children)); + auto struct_type = make_uniq(LogicalType::STRUCT(std::move(child_types)), std::move(type_info)); + return struct_type; + } else if (format[0] == '+' && format[1] == 'u') { + if (format[2] != 's') { + throw NotImplementedException("Unsupported Internal Arrow Type: \"%c\" Union", format[2]); + } + D_ASSERT(format[3] == ':'); + + std::string prefix = "+us:"; + // TODO: what are these type ids actually for? + auto type_ids = StringUtil::Split(format.substr(prefix.size()), ','); + + child_list_t members; + vector> children; + if (schema.n_children == 0) { + throw InvalidInputException("Attempted to convert a UNION with no fields to DuckDB which is not supported"); + } + for (idx_t type_idx = 0; type_idx < static_cast(schema.n_children); type_idx++) { + auto type = schema.children[type_idx]; + + children.emplace_back(GetArrowLogicalType(config, *type)); + members.emplace_back(type->name, children.back()->GetDuckType()); + } + + auto type_info = make_uniq(std::move(children)); + auto union_type = make_uniq(LogicalType::UNION(members), std::move(type_info)); + return union_type; + } else if (format == "+r") { + child_list_t members; + vector> children; + idx_t n_children = static_cast(schema.n_children); + D_ASSERT(n_children == 2); + D_ASSERT(string(schema.children[0]->name) == "run_ends"); + D_ASSERT(string(schema.children[1]->name) == "values"); + for (idx_t i = 0; i < n_children; i++) { + auto type = schema.children[i]; + children.emplace_back(GetArrowLogicalType(config, *type)); + members.emplace_back(type->name, children.back()->GetDuckType()); + } + + auto type_info = make_uniq(std::move(children)); + auto struct_type = make_uniq(LogicalType::STRUCT(members), std::move(type_info)); + struct_type->SetRunEndEncoded(); + return struct_type; + } else if (format == "+m") { + auto &arrow_struct_type = *schema.children[0]; + D_ASSERT(arrow_struct_type.n_children == 2); + auto key_type = GetArrowLogicalType(config, *arrow_struct_type.children[0]); + auto value_type = GetArrowLogicalType(config, *arrow_struct_type.children[1]); + child_list_t key_value; + key_value.emplace_back(std::make_pair("key", key_type->GetDuckType())); + key_value.emplace_back(std::make_pair("value", value_type->GetDuckType())); + + auto map_type = LogicalType::MAP(key_type->GetDuckType(), value_type->GetDuckType()); + vector> children; + children.reserve(2); + children.push_back(std::move(key_type)); + children.push_back(std::move(value_type)); + auto inner_struct = make_uniq(LogicalType::STRUCT(std::move(key_value)), + make_uniq(std::move(children))); + auto map_type_info = ArrowListInfo::List(std::move(inner_struct), ArrowVariableSizeType::NORMAL); + return make_uniq(map_type, std::move(map_type_info)); + } + throw NotImplementedException("Unsupported Internal Arrow Type %s", format); +} + +unique_ptr ArrowType::CreateListType(DBConfig &config, ArrowSchema &child, ArrowVariableSizeType size_type, + bool view) { + auto child_type = GetArrowLogicalType(config, child); + + unique_ptr type_info; + auto type = LogicalType::LIST(child_type->GetDuckType()); + if (view) { + type_info = ArrowListInfo::ListView(std::move(child_type), size_type); + } else { + type_info = ArrowListInfo::List(std::move(child_type), size_type); + } + return make_uniq(type, std::move(type_info)); +} + LogicalType ArrowType::GetDuckType(bool use_dictionary) const { if (use_dictionary && dictionary_type) { return dictionary_type->GetDuckType(); } if (!use_dictionary) { + if (extension_data) { + return extension_data->GetDuckDBType(); + } return type; } // Dictionaries can exist in arbitrarily nested schemas @@ -95,9 +333,57 @@ LogicalType ArrowType::GetDuckType(bool use_dictionary) const { return LogicalType::UNION(std::move(new_children)); } default: { + if (extension_data) { + return extension_data->GetDuckDBType(); + } return type; } } } +unique_ptr ArrowType::GetArrowLogicalType(DBConfig &config, ArrowSchema &schema) { + auto arrow_type = ArrowType::GetTypeFromSchema(config, schema); + if (schema.dictionary) { + auto dictionary = GetArrowLogicalType(config, *schema.dictionary); + arrow_type->SetDictionary(std::move(dictionary)); + } + return arrow_type; +} + +bool ArrowType::HasExtension() const { + return extension_data.get() != nullptr; +} + +unique_ptr ArrowType::GetTypeFromSchema(DBConfig &config, ArrowSchema &schema) { + auto format = string(schema.format); + // Let's first figure out if this type is an extension type + ArrowSchemaMetadata schema_metadata(schema.metadata); + auto arrow_type = GetTypeFromFormat(config, schema, format); + if (schema_metadata.HasExtension()) { + auto extension_info = schema_metadata.GetExtensionInfo(string(format)); + arrow_type->extension_data = config.GetArrowExtension(extension_info).GetTypeExtension(); + } + return arrow_type; +} + +LogicalType ArrowTypeExtensionData::GetInternalType() const { + return internal_type; +} + +unordered_map> +ArrowTypeExtensionData::GetExtensionTypes(ClientContext &context, const vector &duckdb_types) { + unordered_map> extension_types; + const auto &db_config = DBConfig::GetConfig(context); + for (idx_t i = 0; i < duckdb_types.size(); i++) { + if (db_config.HasArrowExtension(duckdb_types[i])) { + extension_types.insert({i, db_config.GetArrowExtension(duckdb_types[i]).GetTypeExtension()}); + } + } + return extension_types; +} + +LogicalType ArrowTypeExtensionData::GetDuckDBType() const { + return duckdb_type; +} + } // namespace duckdb diff --git a/src/duckdb/src/function/table/arrow/arrow_type_info.cpp b/src/duckdb/src/function/table/arrow/arrow_type_info.cpp index e012f1b5c..ed9c45449 100644 --- a/src/duckdb/src/function/table/arrow/arrow_type_info.cpp +++ b/src/duckdb/src/function/table/arrow/arrow_type_info.cpp @@ -17,7 +17,7 @@ ArrowTypeInfo::~ArrowTypeInfo() { // ArrowStructInfo //===--------------------------------------------------------------------===// -ArrowStructInfo::ArrowStructInfo(vector> children) +ArrowStructInfo::ArrowStructInfo(vector> children) : ArrowTypeInfo(ArrowTypeInfoType::STRUCT), children(std::move(children)) { } @@ -33,7 +33,7 @@ const ArrowType &ArrowStructInfo::GetChild(idx_t index) const { return *children[index]; } -const vector> &ArrowStructInfo::GetChildren() const { +const vector> &ArrowStructInfo::GetChildren() const { return children; } @@ -81,21 +81,21 @@ idx_t ArrowStringInfo::FixedSize() const { // ArrowListInfo //===--------------------------------------------------------------------===// -ArrowListInfo::ArrowListInfo(unique_ptr child, ArrowVariableSizeType size) +ArrowListInfo::ArrowListInfo(shared_ptr child, ArrowVariableSizeType size) : ArrowTypeInfo(ArrowTypeInfoType::LIST), size_type(size), child(std::move(child)) { } ArrowListInfo::~ArrowListInfo() { } -unique_ptr ArrowListInfo::ListView(unique_ptr child, ArrowVariableSizeType size) { +unique_ptr ArrowListInfo::ListView(shared_ptr child, ArrowVariableSizeType size) { D_ASSERT(size == ArrowVariableSizeType::SUPER_SIZE || size == ArrowVariableSizeType::NORMAL); auto list_info = unique_ptr(new ArrowListInfo(std::move(child), size)); list_info->is_view = true; return list_info; } -unique_ptr ArrowListInfo::List(unique_ptr child, ArrowVariableSizeType size) { +unique_ptr ArrowListInfo::List(shared_ptr child, ArrowVariableSizeType size) { D_ASSERT(size == ArrowVariableSizeType::SUPER_SIZE || size == ArrowVariableSizeType::NORMAL); return unique_ptr(new ArrowListInfo(std::move(child), size)); } @@ -116,7 +116,7 @@ ArrowType &ArrowListInfo::GetChild() const { // ArrowArrayInfo //===--------------------------------------------------------------------===// -ArrowArrayInfo::ArrowArrayInfo(unique_ptr child, idx_t fixed_size) +ArrowArrayInfo::ArrowArrayInfo(shared_ptr child, idx_t fixed_size) : ArrowTypeInfo(ArrowTypeInfoType::ARRAY), child(std::move(child)), fixed_size(fixed_size) { D_ASSERT(fixed_size > 0); } diff --git a/src/duckdb/src/function/table/arrow_conversion.cpp b/src/duckdb/src/function/table/arrow_conversion.cpp index e09f81aac..666712ffc 100644 --- a/src/duckdb/src/function/table/arrow_conversion.cpp +++ b/src/duckdb/src/function/table/arrow_conversion.cpp @@ -768,6 +768,18 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca uint64_t parent_offset) { auto &scan_state = array_state.state; D_ASSERT(!array.dictionary); + if (arrow_type.HasExtension()) { + if (arrow_type.extension_data->arrow_to_duckdb) { + // We allocate with the internal type, and cast to the end result + Vector input_data(arrow_type.extension_data->GetInternalType()); + // FIXME do we need this? + auto input_arrow_type = ArrowType(arrow_type.extension_data->GetInternalType()); + ColumnArrowToDuckDB(input_data, array, array_state, size, input_arrow_type, nested_offset, parent_mask, + parent_offset); + arrow_type.extension_data->arrow_to_duckdb(array_state.context, input_data, vector, size); + return; + } + } if (vector.GetBuffer()) { vector.GetBuffer()->SetAuxiliaryData(make_uniq(array_state.owned_data)); diff --git a/src/duckdb/src/function/table/system/duckdb_log.cpp b/src/duckdb/src/function/table/system/duckdb_log.cpp new file mode 100644 index 000000000..c0bf42975 --- /dev/null +++ b/src/duckdb/src/function/table/system/duckdb_log.cpp @@ -0,0 +1,64 @@ +#include "duckdb/function/table/system_functions.hpp" + +#include "duckdb/main/client_context.hpp" +#include "duckdb/parser/parser.hpp" +#include "duckdb/parser/parser_options.hpp" +#include "duckdb/logging/log_manager.hpp" +#include "duckdb/logging/log_storage.hpp" +#include "duckdb/parser/tableref/subqueryref.hpp" + +namespace duckdb { + +struct DuckDBLogData : public GlobalTableFunctionState { + explicit DuckDBLogData(shared_ptr log_storage_p) : log_storage(std::move(log_storage_p)) { + scan_state = log_storage->CreateScanEntriesState(); + log_storage->InitializeScanEntries(*scan_state); + } + DuckDBLogData() : log_storage(nullptr) { + } + + //! The log storage we are scanning + shared_ptr log_storage; + unique_ptr scan_state; +}; + +static unique_ptr DuckDBLogBind(ClientContext &context, TableFunctionBindInput &input, + vector &return_types, vector &names) { + names.emplace_back("context_id"); + return_types.emplace_back(LogicalType::UBIGINT); + + names.emplace_back("timestamp"); + return_types.emplace_back(LogicalType::TIMESTAMP); + + names.emplace_back("type"); + return_types.emplace_back(LogicalType::VARCHAR); + + names.emplace_back("log_level"); + return_types.emplace_back(LogicalType::VARCHAR); + + names.emplace_back("message"); + return_types.emplace_back(LogicalType::VARCHAR); + + return nullptr; +} + +unique_ptr DuckDBLogInit(ClientContext &context, TableFunctionInitInput &input) { + if (LogManager::Get(context).CanScan()) { + return make_uniq(LogManager::Get(context).GetLogStorage()); + } + return make_uniq(); +} + +void DuckDBLogFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) { + auto &data = data_p.global_state->Cast(); + if (data.log_storage) { + data.log_storage->ScanEntries(*data.scan_state, output); + } +} + +void DuckDBLogFun::RegisterFunction(BuiltinFunctions &set) { + TableFunction logs_fun("duckdb_logs", {}, DuckDBLogFunction, DuckDBLogBind, DuckDBLogInit); + set.AddFunction(logs_fun); +} + +} // namespace duckdb diff --git a/src/duckdb/src/function/table/system/duckdb_log_contexts.cpp b/src/duckdb/src/function/table/system/duckdb_log_contexts.cpp new file mode 100644 index 000000000..d0c5c3b35 --- /dev/null +++ b/src/duckdb/src/function/table/system/duckdb_log_contexts.cpp @@ -0,0 +1,65 @@ +#include "duckdb/function/table/system_functions.hpp" + +#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" + +namespace duckdb { + +struct DuckDBLogContextData : public GlobalTableFunctionState { + explicit DuckDBLogContextData(shared_ptr log_storage_p) : log_storage(std::move(log_storage_p)) { + scan_state = log_storage->CreateScanContextsState(); + log_storage->InitializeScanContexts(*scan_state); + } + DuckDBLogContextData() : log_storage(nullptr) { + } + + //! The log storage we are scanning + shared_ptr log_storage; + unique_ptr scan_state; +}; + +static unique_ptr DuckDBLogContextBind(ClientContext &context, TableFunctionBindInput &input, + vector &return_types, vector &names) { + names.emplace_back("context_id"); + return_types.emplace_back(LogicalType::UBIGINT); + + names.emplace_back("scope"); + return_types.emplace_back(LogicalType::VARCHAR); + + names.emplace_back("client_context"); + return_types.emplace_back(LogicalType::UBIGINT); + + names.emplace_back("transaction_id"); + return_types.emplace_back(LogicalType::UBIGINT); + + names.emplace_back("thread"); + return_types.emplace_back(LogicalType::UBIGINT); + + return nullptr; +} + +unique_ptr DuckDBLogContextInit(ClientContext &context, TableFunctionInitInput &input) { + if (LogManager::Get(context).CanScan()) { + return make_uniq(LogManager::Get(context).GetLogStorage()); + } + return make_uniq(); +} + +void DuckDBLogContextFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) { + auto &data = data_p.global_state->Cast(); + if (data.log_storage) { + data.log_storage->ScanContexts(*data.scan_state, output); + } +} + +void DuckDBLogContextFun::RegisterFunction(BuiltinFunctions &set) { + set.AddFunction( + TableFunction("duckdb_log_contexts", {}, DuckDBLogContextFunction, DuckDBLogContextBind, DuckDBLogContextInit)); +} + +} // namespace duckdb diff --git a/src/duckdb/src/function/table/system_functions.cpp b/src/duckdb/src/function/table/system_functions.cpp index 7560221c5..71eb52e00 100644 --- a/src/duckdb/src/function/table/system_functions.cpp +++ b/src/duckdb/src/function/table/system_functions.cpp @@ -23,6 +23,8 @@ void BuiltinFunctions::RegisterSQLiteFunctions() { DuckDBDatabasesFun::RegisterFunction(*this); DuckDBFunctionsFun::RegisterFunction(*this); DuckDBKeywordsFun::RegisterFunction(*this); + DuckDBLogFun::RegisterFunction(*this); + DuckDBLogContextFun::RegisterFunction(*this); DuckDBIndexesFun::RegisterFunction(*this); DuckDBSchemasFun::RegisterFunction(*this); DuckDBDependenciesFun::RegisterFunction(*this); diff --git a/src/duckdb/src/function/table/table_scan.cpp b/src/duckdb/src/function/table/table_scan.cpp index b36abbb9b..dafe070d1 100644 --- a/src/duckdb/src/function/table/table_scan.cpp +++ b/src/duckdb/src/function/table/table_scan.cpp @@ -11,7 +11,6 @@ #include "duckdb/main/client_config.hpp" #include "duckdb/optimizer/matcher/expression_matcher.hpp" #include "duckdb/planner/expression/bound_between_expression.hpp" -#include "duckdb/planner/expression_iterator.hpp" #include "duckdb/planner/operator/logical_get.hpp" #include "duckdb/storage/data_table.hpp" #include "duckdb/storage/table/scan_state.hpp" @@ -71,7 +70,8 @@ class TableScanGlobalState : public GlobalTableFunctionState { TableScanGlobalState(ClientContext &context, const FunctionData *bind_data_p) { D_ASSERT(bind_data_p); auto &bind_data = bind_data_p->Cast(); - max_threads = bind_data.table.GetStorage().MaxThreads(context); + auto &duck_table = bind_data.table.Cast(); + max_threads = duck_table.GetStorage().MaxThreads(context); } //! The maximum number of threads for this table scan. @@ -130,8 +130,9 @@ class DuckIndexScanState : public TableScanGlobalState { void TableScanFunc(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) override { auto &bind_data = data_p.bind_data->Cast(); - auto &tx = DuckTransaction::Get(context, bind_data.table.catalog); - auto &storage = bind_data.table.GetStorage(); + auto &duck_table = bind_data.table.Cast(); + auto &tx = DuckTransaction::Get(context, duck_table.catalog); + auto &storage = duck_table.GetStorage(); auto &l_state = data_p.local_state->Cast(); auto row_id_count = row_ids.size(); @@ -216,7 +217,8 @@ class DuckTableScanState : public TableScanGlobalState { l_state->scan_state.Initialize(std::move(storage_ids), input.filters.get(), input.sample_options.get()); - auto &storage = bind_data.table.GetStorage(); + auto &duck_table = bind_data.table.Cast(); + auto &storage = duck_table.GetStorage(); storage.NextParallelScan(context.client, state, l_state->scan_state); if (input.CanRemoveFilterColumns()) { l_state->all_columns.Initialize(context.client, scanned_types); @@ -228,8 +230,9 @@ class DuckTableScanState : public TableScanGlobalState { void TableScanFunc(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) override { auto &bind_data = data_p.bind_data->Cast(); - auto &tx = DuckTransaction::Get(context, bind_data.table.catalog); - auto &storage = bind_data.table.GetStorage(); + auto &duck_table = bind_data.table.Cast(); + auto &tx = DuckTransaction::Get(context, duck_table.catalog); + auto &storage = duck_table.GetStorage(); auto &l_state = data_p.local_state->Cast(); l_state.scan_state.options.force_fetch_row = ClientConfig::GetConfig(context).force_fetch_row; @@ -258,7 +261,8 @@ class DuckTableScanState : public TableScanGlobalState { double TableScanProgress(ClientContext &context, const FunctionData *bind_data_p) const override { auto &bind_data = bind_data_p->Cast(); - auto &storage = bind_data.table.GetStorage(); + auto &duck_table = bind_data.table.Cast(); + auto &storage = duck_table.GetStorage(); auto total_rows = storage.GetTotalRows(); // The table is empty or smaller than the standard vector size. @@ -306,7 +310,8 @@ unique_ptr DuckTableScanInitGlobal(ClientContext &cont } g_state->projection_ids = input.projection_ids; - const auto &columns = bind_data.table.GetColumns(); + auto &duck_table = bind_data.table.Cast(); + const auto &columns = duck_table.GetColumns(); for (const auto &col_idx : input.column_indexes) { if (col_idx.IsRowIdColumn()) { g_state->scanned_types.emplace_back(LogicalType::ROW_TYPE); @@ -327,14 +332,15 @@ unique_ptr DuckIndexScanInitGlobal(ClientContext &cont } g_state->finished = g_state->row_ids.empty() ? true : false; - auto &local_storage = LocalStorage::Get(context, bind_data.table.catalog); + auto &duck_table = bind_data.table.Cast(); + auto &local_storage = LocalStorage::Get(context, duck_table.catalog); g_state->table_scan_state.options.force_fetch_row = ClientConfig::GetConfig(context).force_fetch_row; if (input.CanRemoveFilterColumns()) { g_state->projection_ids = input.projection_ids; } - const auto &columns = bind_data.table.GetColumns(); + const auto &columns = duck_table.GetColumns(); for (const auto &col_idx : input.column_indexes) { g_state->column_ids.push_back(GetStorageIndex(bind_data.table, col_idx)); if (col_idx.IsRowIdColumn()) { @@ -467,8 +473,8 @@ unique_ptr TableScanInitGlobal(ClientContext &context, D_ASSERT(input.bind_data); auto &bind_data = input.bind_data->Cast(); - auto &table = bind_data.table; - auto &storage = table.GetStorage(); + auto &duck_table = bind_data.table.Cast(); + auto &storage = duck_table.GetStorage(); // Can't index scan without filters. if (!input.filters) { @@ -502,7 +508,7 @@ unique_ptr TableScanInitGlobal(ClientContext &context, auto total_rows_from_percentage = LossyNumericCast(double(total_rows) * scan_percentage); auto max_count = MaxValue(scan_max_count, total_rows_from_percentage); - auto &column_list = table.GetColumns(); + auto &column_list = duck_table.GetColumns(); bool index_scan = false; unsafe_vector row_ids; @@ -520,13 +526,14 @@ unique_ptr TableScanInitGlobal(ClientContext &context, static unique_ptr TableScanStatistics(ClientContext &context, const FunctionData *bind_data_p, column_t column_id) { auto &bind_data = bind_data_p->Cast(); - auto &local_storage = LocalStorage::Get(context, bind_data.table.catalog); + auto &duck_table = bind_data.table.Cast(); + auto &local_storage = LocalStorage::Get(context, duck_table.catalog); // Don't emit statistics for tables with outstanding transaction-local data. - if (local_storage.Find(bind_data.table.GetStorage())) { + if (local_storage.Find(duck_table.GetStorage())) { return nullptr; } - return bind_data.table.GetStatistics(context, column_id); + return duck_table.GetStatistics(context, column_id); } static void TableScanFunc(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) { @@ -552,7 +559,8 @@ OperatorPartitionData TableScanGetPartitionData(ClientContext &context, TableFun vector TableScanGetPartitionStats(ClientContext &context, GetPartitionStatsInput &input) { auto &bind_data = input.bind_data->Cast(); vector result; - auto &storage = bind_data.table.GetStorage(); + auto &duck_table = bind_data.table.Cast(); + auto &storage = duck_table.GetStorage(); return storage.GetPartitionStats(context); } @@ -568,10 +576,11 @@ void TableScanDependency(LogicalDependencyList &entries, const FunctionData *bin unique_ptr TableScanCardinality(ClientContext &context, const FunctionData *bind_data_p) { auto &bind_data = bind_data_p->Cast(); - auto &local_storage = LocalStorage::Get(context, bind_data.table.catalog); - auto &storage = bind_data.table.GetStorage(); + auto &duck_table = bind_data.table.Cast(); + auto &local_storage = LocalStorage::Get(context, duck_table.catalog); + auto &storage = duck_table.GetStorage(); idx_t table_rows = storage.GetTotalRows(); - idx_t estimated_cardinality = table_rows + local_storage.AddedRows(bind_data.table.GetStorage()); + idx_t estimated_cardinality = table_rows + local_storage.AddedRows(duck_table.GetStorage()); return make_uniq(table_rows, estimated_cardinality); } diff --git a/src/duckdb/src/function/table/version/pragma_version.cpp b/src/duckdb/src/function/table/version/pragma_version.cpp index bc8341084..48497da5d 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 "4-dev4329" +#define DUCKDB_PATCH_VERSION "4-dev4483" #endif #ifndef DUCKDB_MINOR_VERSION #define DUCKDB_MINOR_VERSION 1 @@ -8,10 +8,10 @@ #define DUCKDB_MAJOR_VERSION 1 #endif #ifndef DUCKDB_VERSION -#define DUCKDB_VERSION "v1.1.4-dev4329" +#define DUCKDB_VERSION "v1.1.4-dev4483" #endif #ifndef DUCKDB_SOURCE_ID -#define DUCKDB_SOURCE_ID "a1c7e9b115" +#define DUCKDB_SOURCE_ID "1c6ea28bdc" #endif #include "duckdb/function/table/system_functions.hpp" #include "duckdb/main/database.hpp" diff --git a/src/duckdb/src/include/duckdb/catalog/catalog.hpp b/src/duckdb/src/include/duckdb/catalog/catalog.hpp index dbef14ee5..121b047cb 100644 --- a/src/duckdb/src/include/duckdb/catalog/catalog.hpp +++ b/src/duckdb/src/include/duckdb/catalog/catalog.hpp @@ -298,7 +298,7 @@ class Catalog { virtual unique_ptr PlanUpdate(ClientContext &context, LogicalUpdate &op, unique_ptr plan) = 0; virtual unique_ptr BindCreateIndex(Binder &binder, CreateStatement &stmt, TableCatalogEntry &table, - unique_ptr plan) = 0; + unique_ptr plan); virtual unique_ptr BindAlterAddIndex(Binder &binder, TableCatalogEntry &table_entry, unique_ptr plan, unique_ptr create_info, diff --git a/src/duckdb/src/include/duckdb/common/arrow/appender/append_data.hpp b/src/duckdb/src/include/duckdb/common/arrow/appender/append_data.hpp index eedc63db9..1b5a5e02a 100644 --- a/src/duckdb/src/include/duckdb/common/arrow/appender/append_data.hpp +++ b/src/duckdb/src/include/duckdb/common/arrow/appender/append_data.hpp @@ -6,6 +6,7 @@ #include "duckdb/common/arrow/arrow_buffer.hpp" #include "duckdb/main/client_properties.hpp" #include "duckdb/common/array.hpp" +#include "duckdb/function/table/arrow/arrow_duck_schema.hpp" namespace duckdb { @@ -28,7 +29,7 @@ typedef void (*finalize_t)(ArrowAppendData &append_data, const LogicalType &type // FIXME: we should separate the append state variables from the variables required by the ArrowArray into // ArrowAppendState struct ArrowAppendData { - explicit ArrowAppendData(ClientProperties &options_p) : options(options_p) { + explicit ArrowAppendData(const ClientProperties &options_p) : options(options_p) { dictionary.release = nullptr; arrow_buffers.resize(3); } @@ -60,6 +61,8 @@ struct ArrowAppendData { //! function pointers for construction initialize_t initialize = nullptr; append_vector_t append_vector = nullptr; + //! Arrow Extension Type information + shared_ptr extension_data = nullptr; finalize_t finalize = nullptr; //! child data (if any) diff --git a/src/duckdb/src/include/duckdb/common/arrow/arrow_appender.hpp b/src/duckdb/src/include/duckdb/common/arrow/arrow_appender.hpp index 55a85a4aa..8c7579706 100644 --- a/src/duckdb/src/include/duckdb/common/arrow/arrow_appender.hpp +++ b/src/duckdb/src/include/duckdb/common/arrow/arrow_appender.hpp @@ -15,10 +15,13 @@ namespace duckdb { struct ArrowAppendData; +class ArrowTypeExtensionData; + //! The ArrowAppender class can be used to incrementally construct an arrow array by appending data chunks into it class ArrowAppender { public: - DUCKDB_API ArrowAppender(vector types_p, const idx_t initial_capacity, ClientProperties options); + DUCKDB_API ArrowAppender(vector types_p, const idx_t initial_capacity, ClientProperties options, + unordered_map> extension_type_cast); DUCKDB_API ~ArrowAppender(); public: @@ -29,8 +32,9 @@ class ArrowAppender { idx_t RowCount() const; static void ReleaseArray(ArrowArray *array); static ArrowArray *FinalizeChild(const LogicalType &type, unique_ptr append_data_p); - static unique_ptr InitializeChild(const LogicalType &type, const idx_t capacity, - ClientProperties &options); + static unique_ptr + InitializeChild(const LogicalType &type, const idx_t capacity, ClientProperties &options, + const shared_ptr &extension_type = nullptr); static void AddChildren(ArrowAppendData &data, const idx_t count); private: diff --git a/src/duckdb/src/include/duckdb/common/arrow/arrow_converter.hpp b/src/duckdb/src/include/duckdb/common/arrow/arrow_converter.hpp index 2f80fb4a9..f94467b5e 100644 --- a/src/duckdb/src/include/duckdb/common/arrow/arrow_converter.hpp +++ b/src/duckdb/src/include/duckdb/common/arrow/arrow_converter.hpp @@ -11,13 +11,36 @@ #include "duckdb/common/types/data_chunk.hpp" #include "duckdb/common/arrow/arrow.hpp" #include "duckdb/main/client_properties.hpp" +#include namespace duckdb { - +class ArrowTypeExtensionData; +struct DBConfig; struct ArrowConverter { DUCKDB_API static void ToArrowSchema(ArrowSchema *out_schema, const vector &types, - const vector &names, const ClientProperties &options); - DUCKDB_API static void ToArrowArray(DataChunk &input, ArrowArray *out_array, ClientProperties options); + const vector &names, ClientProperties &options); + DUCKDB_API static void + ToArrowArray(DataChunk &input, ArrowArray *out_array, ClientProperties options, + const unordered_map> &extension_type_cast); +}; + +//===--------------------------------------------------------------------===// +// Arrow Schema +//===--------------------------------------------------------------------===// +struct DuckDBArrowSchemaHolder { + // unused in children + vector children; + // unused in children + vector children_ptrs; + //! used for nested structures + std::list> nested_children; + std::list> nested_children_ptr; + //! This holds strings created to represent decimal types + vector> owned_type_names; + vector> owned_column_names; + //! This holds any values created for metadata info + vector> metadata_info; + vector> extension_format; }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/common/arrow/arrow_query_result.hpp b/src/duckdb/src/include/duckdb/common/arrow/arrow_query_result.hpp index 667ae3c61..811a410a5 100644 --- a/src/duckdb/src/include/duckdb/common/arrow/arrow_query_result.hpp +++ b/src/duckdb/src/include/duckdb/common/arrow/arrow_query_result.hpp @@ -20,7 +20,7 @@ class ClientContext; class ArrowQueryResult : public QueryResult { public: - static constexpr const QueryResultType TYPE = QueryResultType::ARROW_RESULT; + static constexpr QueryResultType TYPE = QueryResultType::ARROW_RESULT; public: friend class ClientContext; diff --git a/src/duckdb/src/include/duckdb/common/arrow/arrow_type_extension.hpp b/src/duckdb/src/include/duckdb/common/arrow/arrow_type_extension.hpp new file mode 100644 index 000000000..bc2e50c1c --- /dev/null +++ b/src/duckdb/src/include/duckdb/common/arrow/arrow_type_extension.hpp @@ -0,0 +1,144 @@ +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/common/arrow/arrow_type_extension.hpp +// +// +//===----------------------------------------------------------------------===// + +#pragma once + +#include "duckdb/main/query_result.hpp" +#include "duckdb/common/arrow/arrow_wrapper.hpp" +#include "duckdb/main/chunk_scan_state.hpp" +#include "duckdb/function/table/arrow/arrow_duck_schema.hpp" +#include + +namespace duckdb { +class ArrowSchemaMetadata; +struct DuckDBArrowSchemaHolder; + +struct DBConfig; +struct ArrowExtensionMetadata { +public: + ArrowExtensionMetadata() { + } + + ArrowExtensionMetadata(string extension_name, string vendor_name, string type_name, string arrow_format); + + hash_t GetHash() const; + + string ToString() const; + + string GetExtensionName() const; + + string GetVendorName() const; + + string GetTypeName() const; + + string GetArrowFormat() const; + + void SetArrowFormat(string arrow_format); + + bool IsCanonical() const; + + bool operator==(const ArrowExtensionMetadata &other) const; + + //! Arrow Extension for non-canonical types. + static constexpr const char *ARROW_EXTENSION_NON_CANONICAL = "arrow.opaque"; + +private: + //! The extension name (e.g., 'arrow.uuid', 'arrow.opaque',...) + string extension_name {}; + //! If the extension name is 'arrow.opaque' a vendor and type must be defined. + //! The vendor_name is the system that produced the type (e.g., DuckDB) + string vendor_name {}; + //! The type_name is the name of the type produced by the vendor (e.g., hugeint) + string type_name {}; + //! The arrow format (e.g., z) + string arrow_format {}; +}; + +class ArrowTypeExtension; + +typedef void (*populate_arrow_schema_t)(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, + const LogicalType &type, ClientContext &context, + const ArrowTypeExtension &extension); + +typedef shared_ptr (*get_type_t)(const ArrowSchema &schema, const ArrowSchemaMetadata &schema_metadata); + +class ArrowTypeExtension { +public: + ArrowTypeExtension() {}; + //! We either have simple extensions where we only return one type + ArrowTypeExtension(string extension_name, string arrow_format, shared_ptr type); + ArrowTypeExtension(string vendor_name, string type_name, string arrow_format, + shared_ptr type); + + //! We have complex extensions, where we can return multiple types, hence we must have callback functions to do so + ArrowTypeExtension(string extension_name, populate_arrow_schema_t populate_arrow_schema, get_type_t get_type, + shared_ptr type); + ArrowTypeExtension(string vendor_name, string type_name, populate_arrow_schema_t populate_arrow_schema, + get_type_t get_type, shared_ptr type, cast_arrow_duck_t arrow_to_duckdb, + cast_duck_arrow_t duckdb_to_arrow); + + ArrowExtensionMetadata GetInfo() const; + + shared_ptr GetType(const ArrowSchema &schema, const ArrowSchemaMetadata &schema_metadata) const; + + shared_ptr GetTypeExtension() const; + + LogicalTypeId GetLogicalTypeId() const; + + LogicalType GetLogicalType() const; + + bool HasType() const; + + static void PopulateArrowSchema(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, + const LogicalType &duckdb_type, ClientContext &context, + const ArrowTypeExtension &extension); + + //! (Optional) Callback to a function that sets up the arrow schema production + populate_arrow_schema_t populate_arrow_schema = nullptr; + //! (Optional) Callback to a function that sets up the arrow schema production + get_type_t get_type = nullptr; + +private: + //! Extension Info from Arrow + ArrowExtensionMetadata extension_metadata; + //! Arrow Extension Type + shared_ptr type_extension; +}; + +struct HashArrowTypeExtension { + size_t operator()(ArrowExtensionMetadata const &arrow_extension_info) const noexcept { + return arrow_extension_info.GetHash(); + } +}; + +struct TypeInfo { + TypeInfo(); + explicit TypeInfo(const LogicalType &type); + explicit TypeInfo(string alias); + string alias; + LogicalTypeId type; + hash_t GetHash() const; + bool operator==(const TypeInfo &other) const; +}; + +struct HashTypeInfo { + size_t operator()(TypeInfo const &type_info) const noexcept { + return type_info.GetHash(); + } +}; + +//! The set of encoding functions +struct ArrowTypeExtensionSet { + ArrowTypeExtensionSet() {}; + static void Initialize(const DBConfig &config); + std::mutex lock; + unordered_map type_extensions; + unordered_map, HashTypeInfo> type_to_info; +}; + +} // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/common/arrow/arrow_util.hpp b/src/duckdb/src/include/duckdb/common/arrow/arrow_util.hpp index d49cade58..eb9e45e71 100644 --- a/src/duckdb/src/include/duckdb/common/arrow/arrow_util.hpp +++ b/src/duckdb/src/include/duckdb/common/arrow/arrow_util.hpp @@ -17,12 +17,15 @@ namespace duckdb { class QueryResult; class DataChunk; +class ArrowTypeExtensionData; class ArrowUtil { public: static bool TryFetchChunk(ChunkScanState &scan_state, ClientProperties options, idx_t chunk_size, ArrowArray *out, - idx_t &result_count, ErrorData &error); - static idx_t FetchChunk(ChunkScanState &scan_state, ClientProperties options, idx_t chunk_size, ArrowArray *out); + idx_t &result_count, ErrorData &error, + unordered_map> extension_type_cast); + static idx_t FetchChunk(ChunkScanState &scan_state, ClientProperties options, idx_t chunk_size, ArrowArray *out, + const unordered_map> &extension_type_cast); private: static bool TryFetchNext(QueryResult &result, unique_ptr &out, ErrorData &error); diff --git a/src/duckdb/src/include/duckdb/common/arrow/result_arrow_wrapper.hpp b/src/duckdb/src/include/duckdb/common/arrow/result_arrow_wrapper.hpp index f82e472dd..67e8cf12d 100644 --- a/src/duckdb/src/include/duckdb/common/arrow/result_arrow_wrapper.hpp +++ b/src/duckdb/src/include/duckdb/common/arrow/result_arrow_wrapper.hpp @@ -11,6 +11,7 @@ #include "duckdb/main/query_result.hpp" #include "duckdb/common/arrow/arrow_wrapper.hpp" #include "duckdb/main/chunk_scan_state.hpp" +#include "duckdb/function/table/arrow/arrow_duck_schema.hpp" namespace duckdb { class ResultArrowArrayStreamWrapper { @@ -25,6 +26,7 @@ class ResultArrowArrayStreamWrapper { vector column_types; vector column_names; unique_ptr scan_state; + unordered_map> extension_types; private: static int MyStreamGetSchema(struct ArrowArrayStream *stream, struct ArrowSchema *out); diff --git a/src/duckdb/src/include/duckdb/common/arrow/schema_metadata.hpp b/src/duckdb/src/include/duckdb/common/arrow/schema_metadata.hpp index 833d455a8..1aff53718 100644 --- a/src/duckdb/src/include/duckdb/common/arrow/schema_metadata.hpp +++ b/src/duckdb/src/include/duckdb/common/arrow/schema_metadata.hpp @@ -11,6 +11,7 @@ #include "duckdb/main/query_result.hpp" #include "duckdb/common/arrow/arrow_wrapper.hpp" #include "duckdb/main/chunk_scan_state.hpp" +#include "duckdb/common/arrow/arrow_type_extension.hpp" namespace duckdb { class ArrowSchemaMetadata { @@ -27,20 +28,18 @@ class ArrowSchemaMetadata { unsafe_unique_array SerializeMetadata() const; //! If the arrow extension is set bool HasExtension() const; - //! If this extension type is an 'arrow.opaque', and the internal type and vendors match. - bool IsNonCanonicalType(const string &type, const string &vendor = "DuckDB") const; + + ArrowExtensionMetadata GetExtensionInfo(string format); //! Get the extension name if set, otherwise returns empty string GetExtensionName() const; //! Key for encode of the extension type name static constexpr const char *ARROW_EXTENSION_NAME = "ARROW:extension:name"; //! Key for encode of the metadata key static constexpr const char *ARROW_METADATA_KEY = "ARROW:extension:metadata"; - //! Arrow Extension for non-canonical types. - static constexpr const char *ARROW_EXTENSION_NON_CANONICAL = "arrow.opaque"; //! Creates the metadata based on an extension name static ArrowSchemaMetadata ArrowCanonicalType(const string &extension_name); //! Creates the metadata based on an extension name - static ArrowSchemaMetadata DuckDBInternalType(const string &type_name); + static ArrowSchemaMetadata NonCanonicalType(const string &type_name, const string &vendor_name); private: //! The unordered map that holds the metadata diff --git a/src/duckdb/src/include/duckdb/common/enum_util.hpp b/src/duckdb/src/include/duckdb/common/enum_util.hpp index 852f43436..d3ab3ac44 100644 --- a/src/duckdb/src/include/duckdb/common/enum_util.hpp +++ b/src/duckdb/src/include/duckdb/common/enum_util.hpp @@ -204,6 +204,12 @@ enum class LimitNodeType : uint8_t; enum class LoadType : uint8_t; +enum class LogContextScope : uint8_t; + +enum class LogLevel : uint8_t; + +enum class LogMode : uint8_t; + enum class LogicalOperatorType : uint8_t; enum class LogicalTypeId : uint8_t; @@ -641,6 +647,15 @@ const char* EnumUtil::ToChars(LimitNodeType value); template<> const char* EnumUtil::ToChars(LoadType value); +template<> +const char* EnumUtil::ToChars(LogContextScope value); + +template<> +const char* EnumUtil::ToChars(LogLevel value); + +template<> +const char* EnumUtil::ToChars(LogMode value); + template<> const char* EnumUtil::ToChars(LogicalOperatorType value); @@ -1167,6 +1182,15 @@ LimitNodeType EnumUtil::FromString(const char *value); template<> LoadType EnumUtil::FromString(const char *value); +template<> +LogContextScope EnumUtil::FromString(const char *value); + +template<> +LogLevel EnumUtil::FromString(const char *value); + +template<> +LogMode EnumUtil::FromString(const char *value); + template<> LogicalOperatorType EnumUtil::FromString(const char *value); diff --git a/src/duckdb/src/include/duckdb/common/file_opener.hpp b/src/duckdb/src/include/duckdb/common/file_opener.hpp index c985e8755..ff7aa9103 100644 --- a/src/duckdb/src/include/duckdb/common/file_opener.hpp +++ b/src/duckdb/src/include/duckdb/common/file_opener.hpp @@ -18,6 +18,7 @@ struct CatalogTransaction; class SecretManager; class ClientContext; class Value; +class Logger; struct FileOpenerInfo { string file_path; @@ -35,6 +36,7 @@ class FileOpener { virtual optional_ptr TryGetClientContext() = 0; virtual optional_ptr TryGetDatabase() = 0; + DUCKDB_API virtual Logger &GetLogger() const = 0; DUCKDB_API static unique_ptr TryGetCatalogTransaction(optional_ptr opener); DUCKDB_API static optional_ptr TryGetClientContext(optional_ptr opener); DUCKDB_API static optional_ptr TryGetDatabase(optional_ptr opener); diff --git a/src/duckdb/src/include/duckdb/function/scalar/system_functions.hpp b/src/duckdb/src/include/duckdb/function/scalar/system_functions.hpp index c7a2fe269..fd82a230b 100644 --- a/src/duckdb/src/include/duckdb/function/scalar/system_functions.hpp +++ b/src/duckdb/src/include/duckdb/function/scalar/system_functions.hpp @@ -33,4 +33,13 @@ struct CombineFun { static ScalarFunction GetFunction(); }; +struct WriteLogFun { + static constexpr const char *Name = "write_log"; + static constexpr const char *Parameters = "string"; + static constexpr const char *Description = "Writes to the logger"; + static constexpr const char *Example = "write_log('Hello')"; + + static ScalarFunctionSet GetFunctions(); +}; + } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/function/table/arrow.hpp b/src/duckdb/src/include/duckdb/function/table/arrow.hpp index 7db6cd363..106c485e5 100644 --- a/src/duckdb/src/include/duckdb/function/table/arrow.hpp +++ b/src/duckdb/src/include/duckdb/function/table/arrow.hpp @@ -50,9 +50,10 @@ struct ArrowScanFunctionData : public TableFunctionData { public: ArrowScanFunctionData(stream_factory_produce_t scanner_producer_p, uintptr_t stream_factory_ptr_p, shared_ptr dependency = nullptr) - : lines_read(0), stream_factory_ptr(stream_factory_ptr_p), scanner_producer(scanner_producer_p), - dependency(std::move(dependency)) { + : lines_read(0), rows_per_thread(0), stream_factory_ptr(stream_factory_ptr_p), + scanner_producer(scanner_producer_p), dependency(std::move(dependency)) { } + vector all_types; atomic lines_read; ArrowSchemaWrapper schema_root; @@ -88,7 +89,7 @@ struct ArrowRunEndEncodingState { struct ArrowScanLocalState; struct ArrowArrayScanState { public: - explicit ArrowArrayScanState(ArrowScanLocalState &state); + explicit ArrowArrayScanState(ArrowScanLocalState &state, ClientContext &context); public: ArrowScanLocalState &state; @@ -101,6 +102,7 @@ struct ArrowArrayScanState { unique_ptr dictionary; //! Run-end-encoding state ArrowRunEndEncodingState run_end_encoding; + ClientContext &context; public: ArrowArrayScanState &GetChild(idx_t child_idx); @@ -126,7 +128,8 @@ struct ArrowArrayScanState { struct ArrowScanLocalState : public LocalTableFunctionState { public: - explicit ArrowScanLocalState(unique_ptr current_chunk) : chunk(current_chunk.release()) { + explicit ArrowScanLocalState(unique_ptr current_chunk, ClientContext &context) + : chunk(current_chunk.release()), context(context) { } public: @@ -139,6 +142,7 @@ struct ArrowScanLocalState : public LocalTableFunctionState { TableFilterSet *filters = nullptr; //! The DataChunk containing all read columns (even filter columns that are immediately removed) DataChunk all_columns; + ClientContext &context; public: void Reset() { @@ -150,7 +154,7 @@ struct ArrowScanLocalState : public LocalTableFunctionState { ArrowArrayScanState &GetState(idx_t child_idx) { auto it = array_states.find(child_idx); if (it == array_states.end()) { - auto child_p = make_uniq(*this); + auto child_p = make_uniq(*this, context); auto &child = *child_p; array_states.emplace(child_idx, std::move(child_p)); return child; @@ -211,7 +215,8 @@ struct ArrowTableFunction { //! Scan Function static void ArrowScanFunction(ClientContext &context, TableFunctionInput &data, DataChunk &output); - static void PopulateArrowTableType(ArrowTableType &arrow_table, ArrowSchemaWrapper &schema_p, vector &names, + static void PopulateArrowTableType(DBConfig &config, ArrowTableType &arrow_table, + const ArrowSchemaWrapper &schema_p, vector &names, vector &return_types); protected: @@ -229,10 +234,6 @@ struct ArrowTableFunction { //! Gets the progress on the table scan, used for Progress Bars static double ArrowProgress(ClientContext &context, const FunctionData *bind_data, const GlobalTableFunctionState *global_state); - -public: - //! Helper function to get the DuckDB logical type - static unique_ptr GetArrowLogicalType(ArrowSchema &schema); }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/function/table/arrow/arrow_duck_schema.hpp b/src/duckdb/src/include/duckdb/function/table/arrow/arrow_duck_schema.hpp index 5c2b710a1..6b09f695c 100644 --- a/src/duckdb/src/include/duckdb/function/table/arrow/arrow_duck_schema.hpp +++ b/src/duckdb/src/include/duckdb/function/table/arrow/arrow_duck_schema.hpp @@ -1,22 +1,61 @@ //===----------------------------------------------------------------------===// // DuckDB // -// duckdb/function/table/arrow_duck_schema.hpp +// duckdb/function/table/arrow/arrow_duck_schema.hpp // // //===----------------------------------------------------------------------===// #pragma once -#include +#include "duckdb/common/types/validity_mask.hpp" #include "duckdb/common/types.hpp" #include "duckdb/common/unordered_map.hpp" -#include "duckdb/common/vector.hpp" #include "duckdb/common/unique_ptr.hpp" #include "duckdb/function/table/arrow/arrow_type_info.hpp" +#include "duckdb/common/arrow/arrow.hpp" namespace duckdb { +struct DBConfig; + +struct ArrowArrayScanState; + +typedef void (*cast_arrow_duck_t)(ClientContext &context, Vector &source, Vector &result, idx_t count); + +typedef void (*cast_duck_arrow_t)(ClientContext &context, Vector &source, Vector &result, idx_t count); + +class ArrowTypeExtensionData { +public: + explicit ArrowTypeExtensionData(const LogicalType &duckdb_type, const LogicalType &internal_type_p, + cast_arrow_duck_t arrow_to_duckdb = nullptr, + cast_duck_arrow_t duckdb_to_arrow = nullptr) + : arrow_to_duckdb(arrow_to_duckdb), duckdb_to_arrow(duckdb_to_arrow), duckdb_type(duckdb_type), + internal_type(internal_type_p) { + } + + explicit ArrowTypeExtensionData(const LogicalType &duckdb_type) + : duckdb_type(duckdb_type), internal_type(duckdb_type) { + } + + //! (Optional) Callback to function that converts an Arrow Array to a DuckDB Vector + cast_arrow_duck_t arrow_to_duckdb = nullptr; + //! (Optional) Callback to function that converts a DuckDB Vector to an Arrow Array + cast_duck_arrow_t duckdb_to_arrow = nullptr; + + LogicalType GetInternalType() const; + + //! This function returns possible extension types to given DuckDB types + static unordered_map> + GetExtensionTypes(ClientContext &context, const vector &duckdb_types); + LogicalType GetDuckDBType() const; + +private: + //! Original DuckDB Type (e.g., UHUGEINT) + LogicalType duckdb_type; + //! Internal type is a type that refers to the produced duckdb vector when consuming the arrow format + LogicalType internal_type; +}; class ArrowType { public: @@ -45,7 +84,21 @@ class ArrowType { } void ThrowIfInvalid() const; -private: + static unique_ptr GetTypeFromFormat(DBConfig &config, ArrowSchema &schema, string &format); + + static unique_ptr GetTypeFromSchema(DBConfig &config, ArrowSchema &schema); + + static unique_ptr CreateListType(DBConfig &config, ArrowSchema &child, ArrowVariableSizeType size_type, + bool view); + + static unique_ptr GetArrowLogicalType(DBConfig &config, ArrowSchema &schema); + + bool HasExtension() const; + + //! The Arrow Type Extension data, if any + shared_ptr extension_data; + +protected: LogicalType type; //! Hold the optional type if the array is a dictionary unique_ptr dictionary_type; @@ -58,11 +111,11 @@ class ArrowType { bool not_implemented = false; }; -using arrow_column_map_t = unordered_map>; +using arrow_column_map_t = unordered_map>; struct ArrowTableType { public: - void AddColumn(idx_t index, unique_ptr type); + void AddColumn(idx_t index, shared_ptr type); const arrow_column_map_t &GetColumns() const; private: diff --git a/src/duckdb/src/include/duckdb/function/table/arrow/arrow_type_info.hpp b/src/duckdb/src/include/duckdb/function/table/arrow/arrow_type_info.hpp index fa8358496..15e1aa3fc 100644 --- a/src/duckdb/src/include/duckdb/function/table/arrow/arrow_type_info.hpp +++ b/src/duckdb/src/include/duckdb/function/table/arrow/arrow_type_info.hpp @@ -23,6 +23,9 @@ class ArrowType; struct ArrowTypeInfo { public: + explicit ArrowTypeInfo() : type() { + } + explicit ArrowTypeInfo(ArrowTypeInfoType type); virtual ~ArrowTypeInfo(); @@ -54,16 +57,16 @@ struct ArrowStructInfo : public ArrowTypeInfo { static constexpr const ArrowTypeInfoType TYPE = ArrowTypeInfoType::STRUCT; public: - explicit ArrowStructInfo(vector> children); + explicit ArrowStructInfo(vector> children); ~ArrowStructInfo() override; public: idx_t ChildCount() const; const ArrowType &GetChild(idx_t index) const; - const vector> &GetChildren() const; + const vector> &GetChildren() const; private: - vector> children; + vector> children; }; struct ArrowDateTimeInfo : public ArrowTypeInfo { @@ -104,8 +107,8 @@ struct ArrowListInfo : public ArrowTypeInfo { static constexpr const ArrowTypeInfoType TYPE = ArrowTypeInfoType::LIST; public: - static unique_ptr ListView(unique_ptr child, ArrowVariableSizeType size); - static unique_ptr List(unique_ptr child, ArrowVariableSizeType size); + static unique_ptr ListView(shared_ptr child, ArrowVariableSizeType size); + static unique_ptr List(shared_ptr child, ArrowVariableSizeType size); ~ArrowListInfo() override; public: @@ -114,12 +117,12 @@ struct ArrowListInfo : public ArrowTypeInfo { ArrowType &GetChild() const; private: - explicit ArrowListInfo(unique_ptr child, ArrowVariableSizeType size); + explicit ArrowListInfo(shared_ptr child, ArrowVariableSizeType size); private: ArrowVariableSizeType size_type; bool is_view = false; - unique_ptr child; + shared_ptr child; }; struct ArrowArrayInfo : public ArrowTypeInfo { @@ -127,7 +130,7 @@ struct ArrowArrayInfo : public ArrowTypeInfo { static constexpr const ArrowTypeInfoType TYPE = ArrowTypeInfoType::ARRAY; public: - explicit ArrowArrayInfo(unique_ptr child, idx_t fixed_size); + explicit ArrowArrayInfo(shared_ptr child, idx_t fixed_size); ~ArrowArrayInfo() override; public: @@ -135,7 +138,7 @@ struct ArrowArrayInfo : public ArrowTypeInfo { ArrowType &GetChild() const; private: - unique_ptr child; + shared_ptr child; idx_t fixed_size; }; diff --git a/src/duckdb/src/include/duckdb/function/table/arrow/enum/arrow_type_info_type.hpp b/src/duckdb/src/include/duckdb/function/table/arrow/enum/arrow_type_info_type.hpp index e478e1531..52b826c33 100644 --- a/src/duckdb/src/include/duckdb/function/table/arrow/enum/arrow_type_info_type.hpp +++ b/src/duckdb/src/include/duckdb/function/table/arrow/enum/arrow_type_info_type.hpp @@ -1,5 +1,7 @@ #pragma once +#include + namespace duckdb { enum class ArrowTypeInfoType : uint8_t { LIST, STRUCT, DATE_TIME, STRING, ARRAY }; diff --git a/src/duckdb/src/include/duckdb/function/table/system_functions.hpp b/src/duckdb/src/include/duckdb/function/table/system_functions.hpp index 689b55201..05e3485e3 100644 --- a/src/duckdb/src/include/duckdb/function/table/system_functions.hpp +++ b/src/duckdb/src/include/duckdb/function/table/system_functions.hpp @@ -83,6 +83,14 @@ struct DuckDBKeywordsFun { static void RegisterFunction(BuiltinFunctions &set); }; +struct DuckDBLogFun { + static void RegisterFunction(BuiltinFunctions &set); +}; + +struct DuckDBLogContextFun { + static void RegisterFunction(BuiltinFunctions &set); +}; + struct DuckDBIndexesFun { static void RegisterFunction(BuiltinFunctions &set); }; diff --git a/src/duckdb/src/include/duckdb/function/table/table_scan.hpp b/src/duckdb/src/include/duckdb/function/table/table_scan.hpp index e5c88e84f..2a888a759 100644 --- a/src/duckdb/src/include/duckdb/function/table/table_scan.hpp +++ b/src/duckdb/src/include/duckdb/function/table/table_scan.hpp @@ -17,11 +17,11 @@ class DuckTableEntry; class TableCatalogEntry; struct TableScanBindData : public TableFunctionData { - explicit TableScanBindData(DuckTableEntry &table) : table(table), is_index_scan(false), is_create_index(false) { + explicit TableScanBindData(TableCatalogEntry &table) : table(table), is_index_scan(false), is_create_index(false) { } //! The table to scan. - DuckTableEntry &table; + TableCatalogEntry &table; //! The old purpose of this field has been deprecated. //! We now use it to express an index scan in the ANALYZE call. //! I.e., we const-cast the bind data and set this to true, if we opt for an index scan. diff --git a/src/duckdb/src/include/duckdb/logging/http_logger.hpp b/src/duckdb/src/include/duckdb/logging/http_logger.hpp index 1ea9fa70e..eb8673743 100644 --- a/src/duckdb/src/include/duckdb/logging/http_logger.hpp +++ b/src/duckdb/src/include/duckdb/logging/http_logger.hpp @@ -15,6 +15,8 @@ #include +// TODO unify with new logger infra in duckdb/logging/logging.hpp + namespace duckdb { //! This has to be templated because we have two namespaces: diff --git a/src/duckdb/src/include/duckdb/logging/log_manager.hpp b/src/duckdb/src/include/duckdb/logging/log_manager.hpp new file mode 100644 index 000000000..90c6384c3 --- /dev/null +++ b/src/duckdb/src/include/duckdb/logging/log_manager.hpp @@ -0,0 +1,81 @@ +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/logging/log_storage.hpp +// +// +//===----------------------------------------------------------------------===// + +#pragma once + +#include "duckdb/logging/logger.hpp" +#include "duckdb/common/types/timestamp.hpp" +#include "duckdb/common/case_insensitive_map.hpp" + +namespace duckdb { + +// Holds global logging state +// - Handles configuration changes +// - Creates Loggers with cached configuration +// - Main sink for logs (either by logging directly into this, or by syncing a pre-cached set of log entries) +// - Holds the log storage +class LogManager : public enable_shared_from_this { + friend class ThreadSafeLogger; + friend class ThreadLocalLogger; + friend class MutableLogger; + +public: + // Note: two step initialization because Logger needs shared pointer to log manager TODO: can we clean up? + explicit LogManager(DatabaseInstance &db, LogConfig config = LogConfig()); + ~LogManager(); + void Initialize(); + + DUCKDB_API static LogManager &Get(ClientContext &context); + unique_ptr CreateLogger(LoggingContext context, bool thread_safe = true, bool mutable_settings = false); + + RegisteredLoggingContext RegisterLoggingContext(LoggingContext &context); + + DUCKDB_API bool RegisterLogStorage(const string &name, shared_ptr &storage); + + //! The global logger can be used whe + DUCKDB_API Logger &GlobalLogger(); + + //! Flush everything + DUCKDB_API void Flush(); + + //! Get a shared_ptr to the log storage (For example, to scan it) + DUCKDB_API shared_ptr GetLogStorage(); + DUCKDB_API bool CanScan(); + + DUCKDB_API void SetEnableLogging(bool enable); + DUCKDB_API void SetLogMode(LogMode mode); + DUCKDB_API void SetLogLevel(LogLevel level); + DUCKDB_API void SetEnabledLogTypes(unordered_set &enabled_log_types); + DUCKDB_API void SetDisabledLogTypes(unordered_set &disabled_log_types); + DUCKDB_API void SetLogStorage(DatabaseInstance &db, const string &storage_name); + + DUCKDB_API LogConfig GetConfig(); + +protected: + RegisteredLoggingContext RegisterLoggingContextInternal(LoggingContext &context); + + // This is to be called by the Loggers only, it does not verify log_level and log_type + void WriteLogEntry(timestamp_t, const char *log_type, LogLevel log_level, const char *log_message, + const RegisteredLoggingContext &context); + // This allows efficiently pushing a cached set of log entries into the log manager + void FlushCachedLogEntries(DataChunk &chunk, const RegisteredLoggingContext &context); + + mutex lock; + LogConfig config; + + unique_ptr global_logger; + + shared_ptr log_storage; + + idx_t next_registered_logging_context_index = 0; + + // Any additional LogStorages registered (by extensions for example) + case_insensitive_map_t> registered_log_storages; +}; + +} // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/logging/log_storage.hpp b/src/duckdb/src/include/duckdb/logging/log_storage.hpp new file mode 100644 index 000000000..f99175b59 --- /dev/null +++ b/src/duckdb/src/include/duckdb/logging/log_storage.hpp @@ -0,0 +1,127 @@ +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/logging/log_storage.hpp +// +// +//===----------------------------------------------------------------------===// + +#pragma once + +#include "duckdb/common/atomic.hpp" +#include "duckdb/common/mutex.hpp" +#include "duckdb/common/optional_idx.hpp" +#include "duckdb/common/types.hpp" +#include "duckdb/common/unordered_set.hpp" + +#include "duckdb/common/types/column/column_data_scan_states.hpp" +#include "duckdb/parallel/thread_context.hpp" + +namespace duckdb { +struct RegisteredLoggingContext; +class ColumnDataCollection; +struct ColumnDataScanState; + +class LogStorageScanState { +public: + virtual ~LogStorageScanState() = default; + + template + TARGET &Cast() { + DynamicCastCheck(this); + return reinterpret_cast(*this); + } + template + const TARGET &Cast() const { + DynamicCastCheck(this); + return reinterpret_cast(*this); + } +}; + +// Interface for writing log entries +class LogStorage { +public: + DUCKDB_API explicit LogStorage() { + } + DUCKDB_API virtual ~LogStorage() = default; + + //! WRITING + DUCKDB_API virtual void WriteLogEntry(timestamp_t timestamp, LogLevel level, const string &log_type, + const string &log_message, const RegisteredLoggingContext &context) = 0; + DUCKDB_API virtual void WriteLogEntries(DataChunk &chunk, const RegisteredLoggingContext &context) = 0; + DUCKDB_API virtual void Flush() = 0; + + //! READING (OPTIONAL) + DUCKDB_API virtual bool CanScan() { + return false; + } + DUCKDB_API virtual unique_ptr CreateScanEntriesState() const; + DUCKDB_API virtual bool ScanEntries(LogStorageScanState &state, DataChunk &result) const; + DUCKDB_API virtual void InitializeScanEntries(LogStorageScanState &state) const; + DUCKDB_API virtual unique_ptr CreateScanContextsState() const; + DUCKDB_API virtual bool ScanContexts(LogStorageScanState &state, DataChunk &result) const; + DUCKDB_API virtual void InitializeScanContexts(LogStorageScanState &state) const; +}; + +class StdOutLogStorage : public LogStorage { +public: + explicit StdOutLogStorage(); + ~StdOutLogStorage() override; + + //! LogStorage API: WRITING + void WriteLogEntry(timestamp_t timestamp, LogLevel level, const string &log_type, const string &log_message, + const RegisteredLoggingContext &context) override; + void WriteLogEntries(DataChunk &chunk, const RegisteredLoggingContext &context) override; + void Flush() override; +}; + +class InMemoryLogStorageScanState : public LogStorageScanState { +public: + InMemoryLogStorageScanState(); + ~InMemoryLogStorageScanState() override; + + ColumnDataScanState scan_state; +}; + +class InMemoryLogStorage : public LogStorage { +public: + explicit InMemoryLogStorage(DatabaseInstance &db); + ~InMemoryLogStorage() override; + + //! LogStorage API: WRITING + void WriteLogEntry(timestamp_t timestamp, LogLevel level, const string &log_type, const string &log_message, + const RegisteredLoggingContext &context) override; + void WriteLogEntries(DataChunk &chunk, const RegisteredLoggingContext &context) override; + void Flush() override; + + //! LogStorage API: READING + bool CanScan() override; + + unique_ptr CreateScanEntriesState() const override; + bool ScanEntries(LogStorageScanState &state, DataChunk &result) const override; + void InitializeScanEntries(LogStorageScanState &state) const override; + unique_ptr CreateScanContextsState() const override; + bool ScanContexts(LogStorageScanState &state, DataChunk &result) const override; + void InitializeScanContexts(LogStorageScanState &state) const override; + +protected: + void WriteLoggingContext(const RegisteredLoggingContext &context); + +protected: + mutable mutex lock; + + void FlushInternal(); + + //! Internal log entry storage + unique_ptr log_entries; + unique_ptr log_contexts; + + unordered_set registered_contexts; + + // Cache for direct logging + unique_ptr entry_buffer; + unique_ptr log_context_buffer; + idx_t max_buffer_size; +}; + +} // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/logging/logger.hpp b/src/duckdb/src/include/duckdb/logging/logger.hpp new file mode 100644 index 000000000..f5e1abab7 --- /dev/null +++ b/src/duckdb/src/include/duckdb/logging/logger.hpp @@ -0,0 +1,287 @@ +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/logging/logger.hpp +// +// +//===----------------------------------------------------------------------===// + +#pragma once + +#include "duckdb/logging/logging.hpp" +#include "duckdb/common/types.hpp" +#include "duckdb/common/string_util.hpp" + +#include + +namespace duckdb { +class TableDescription; +class DatabaseInstance; +class DataChunk; +class LogManager; +class ColumnDataCollection; +class ThreadContext; +class FileOpener; +class LogStorage; +class ExecutionContext; + +//! Main logging interface +class Logger { +public: + DUCKDB_API explicit Logger(LogManager &manager) : manager(manager) { + } + + DUCKDB_API virtual ~Logger() = default; + + //! Main logger functions + DUCKDB_API void Log(const char *log_type, LogLevel log_level, const char *log_message); + DUCKDB_API void Log(LogLevel log_level, const char *log_message); + DUCKDB_API void Log(const char *log_type, LogLevel log_level, const string_t &log_message); + DUCKDB_API void Log(LogLevel log_level, const string_t &log_message); + DUCKDB_API void Log(const char *log_type, LogLevel log_level, std::function callback); + DUCKDB_API void Log(LogLevel log_level, std::function callback); + + // Main interface for subclasses + DUCKDB_API virtual bool ShouldLog(const char *log_type, LogLevel log_level) = 0; + DUCKDB_API virtual bool ShouldLog(LogLevel log_level) = 0; + DUCKDB_API virtual void WriteLog(const char *log_type, LogLevel log_level, const char *message) = 0; + DUCKDB_API virtual void WriteLog(LogLevel log_level, const char *message) = 0; + + DUCKDB_API virtual void Flush() = 0; + + // Get the Logger to write log messages to. In decreasing order of preference(!) so the ThreadContext getter is the + // most preferred way of fetching the logger and the DatabaseInstance getter the least preferred. This has to do + // both with logging performance and level of detail of logging context that is provided. + DUCKDB_API static Logger &Get(const ThreadContext &thread_context); + DUCKDB_API static Logger &Get(const ExecutionContext &execution_context); + DUCKDB_API static Logger &Get(const ClientContext &client_context); + DUCKDB_API static Logger &Get(const FileOpener &opener); + DUCKDB_API static Logger &Get(const DatabaseInstance &db); + + //! Logger::Log with raw C-String + template + static void Log(const char *log_type, T &log_context_source, LogLevel log_level, const char *log_message) { + Logger::Get(log_context_source).Log(log_type, log_level, log_message); + } + template + static void Log(const char *log_type, T &log_context_source, LogLevel log_level, const string &log_message) { + Logger::Get(log_context_source).Log(log_type, log_level, log_message.c_str()); + } + template + static void Log(const char *log_type, T &log_context_source, LogLevel log_level, const string_t &log_message) { + Logger::Get(log_context_source).Log(log_type, log_level, log_message); + } + template + static void Log(T &log_context_source, LogLevel log_level, const char *log_message) { + Logger::Get(log_context_source).Log(log_level, log_message); + } + template + static void Log(T &log_context_source, LogLevel log_level, const string &log_message) { + Logger::Get(log_context_source).Log(log_level, log_message.c_str()); + } + template + static void Log(T &log_context_source, LogLevel log_level, const string_t &log_message) { + Logger::Get(log_context_source).Log(log_level, log_message); + } + + //! Logger::Log with callback + template + static void Log(const char *log_type, T &log_context_source, LogLevel log_level, std::function callback) { + Logger::Get(log_context_source).Log(log_type, log_level, std::move(callback)); + } + template + static void Log(T &log_context_source, LogLevel log_level, std::function callback) { + Logger::Get(log_context_source).Log(log_level, std::move(callback)); + } + //! Logger::Log with StringUtil::Format + template + static void Log(const char *log_type, T &log_context_source, LogLevel log_level, const char *format_string, + ARGS... params) { + Logger::Get(log_context_source).Log(log_type, log_level, [&]() { + return StringUtil::Format(format_string, params...); + }); + } + template + static void Log(T &log_context_source, LogLevel log_level, const char *format_string, ARGS... params) { + Logger::Get(log_context_source).Log(log_level, [&]() { return StringUtil::Format(format_string, params...); }); + } + + //! Templates wrapping Logging::Log(..., LoggingLevel, ....) + template + static void Trace(T &log_context_source, ARGS... params) { + Log(log_context_source, LogLevel::LOG_TRACE, params...); + } + template + static void Trace(const char *log_type, T &log_context_source, ARGS... params) { + Log(log_type, log_context_source, LogLevel::LOG_TRACE, params...); + } + template + static void Debug(T &log_context_source, ARGS... params) { + Log(log_context_source, LogLevel::LOG_DEBUG, params...); + } + template + static void Debug(const char *log_type, T &log_context_source, ARGS... params) { + Log(log_type, log_context_source, LogLevel::LOG_DEBUG, params...); + } + template + static void Info(T &log_context_source, ARGS... params) { + Log(log_context_source, LogLevel::LOG_INFO, params...); + } + template + static void Info(const char *log_type, T &log_context_source, ARGS... params) { + Log(log_type, log_context_source, LogLevel::LOG_INFO, params...); + } + template + static void Warn(T &log_context_source, ARGS... params) { + Log(log_context_source, LogLevel::LOG_WARN, params...); + } + template + static void Warn(const char *log_type, T &log_context_source, ARGS... params) { + Log(log_type, log_context_source, LogLevel::LOG_WARN, params...); + } + template + static void Error(T &log_context_source, ARGS... params) { + Log(log_context_source, LogLevel::LOG_ERROR, params...); + } + template + static void Error(const char *log_type, T &log_context_source, ARGS... params) { + Log(log_type, log_context_source, LogLevel::LOG_ERROR, params...); + } + template + static void Fatal(T &log_context_source, ARGS... params) { + Log(log_context_source, LogLevel::LOG_FATAL, params...); + } + template + static void Fatal(const char *log_type, T &log_context_source, ARGS... params) { + Log(log_type, log_context_source, LogLevel::LOG_FATAL, params...); + } + + template + static void Flush(T &log_context_source) { + Get(log_context_source).Flush(); + } + + DUCKDB_API virtual bool IsThreadSafe() = 0; + DUCKDB_API virtual bool IsMutable() { + return false; + }; + DUCKDB_API virtual void UpdateConfig(LogConfig &new_config) { + throw InternalException("Cannot update the config of this logger!"); + } + DUCKDB_API virtual const LogConfig &GetConfig() const = 0; + +protected: + LogManager &manager; +}; + +// Thread-safe logger +class ThreadSafeLogger : public Logger { +public: + explicit ThreadSafeLogger(LogConfig &config_p, LoggingContext &context_p, LogManager &manager); + explicit ThreadSafeLogger(LogConfig &config_p, RegisteredLoggingContext context_p, LogManager &manager); + + // Main Logger API + bool ShouldLog(const char *log_type, LogLevel log_level) override; + bool ShouldLog(LogLevel log_level) override; + void WriteLog(const char *log_type, LogLevel log_level, const char *message) override; + void WriteLog(LogLevel log_level, const char *message) override; + + void Flush() override; + bool IsThreadSafe() override { + return true; + } + const LogConfig &GetConfig() const override { + return config; + } + +protected: + const LogConfig config; + mutex lock; + const RegisteredLoggingContext context; +}; + +// Non Thread-safe logger +// - will cache log entries locally +class ThreadLocalLogger : public Logger { +public: + explicit ThreadLocalLogger(LogConfig &config_p, LoggingContext &context_p, LogManager &manager); + explicit ThreadLocalLogger(LogConfig &config_p, RegisteredLoggingContext context_p, LogManager &manager); + + // Main Logger API + bool ShouldLog(const char *log_type, LogLevel log_level) override; + bool ShouldLog(LogLevel log_level) override; + void WriteLog(const char *log_type, LogLevel log_level, const char *message) override; + void WriteLog(LogLevel log_level, const char *message) override; + void Flush() override; + + bool IsThreadSafe() override { + return false; + } + const LogConfig &GetConfig() const override { + return config; + } + +protected: + const LogConfig config; + const RegisteredLoggingContext context; +}; + +// Thread-safe Logger with mutable log settings +class MutableLogger : public Logger { +public: + explicit MutableLogger(LogConfig &config_p, LoggingContext &context_p, LogManager &manager); + explicit MutableLogger(LogConfig &config_p, RegisteredLoggingContext context_p, LogManager &manager); + + // Main Logger API + bool ShouldLog(const char *log_type, LogLevel log_level) override; + bool ShouldLog(LogLevel log_level) override; + void WriteLog(const char *log_type, LogLevel log_level, const char *message) override; + void WriteLog(LogLevel log_level, const char *message) override; + + void Flush() override; + bool IsThreadSafe() override { + return true; + } + bool IsMutable() override { + return true; + } + const LogConfig &GetConfig() const override { + return config; + } + void UpdateConfig(LogConfig &new_config) override; + +protected: + // Atomics for lock-free log setting checks + atomic enabled; + atomic mode; + atomic level; + + mutex lock; + LogConfig config; + const RegisteredLoggingContext context; +}; + +// For when logging is disabled: NOPs everything +class NopLogger : public Logger { +public: + explicit NopLogger(LogManager &manager) : Logger(manager) { + } + bool ShouldLog(const char *log_type, LogLevel log_level) override { + return false; + } + bool ShouldLog(LogLevel log_level) override { + return false; + }; + void WriteLog(const char *log_type, LogLevel log_level, const char *message) override {}; + void WriteLog(LogLevel log_level, const char *message) override {}; + void Flush() override { + } + bool IsThreadSafe() override { + return true; + } + const LogConfig &GetConfig() const override { + throw InternalException("Called GetConfig on NopLogger"); + } +}; + +} // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/logging/logging.hpp b/src/duckdb/src/include/duckdb/logging/logging.hpp new file mode 100644 index 000000000..ff354afcd --- /dev/null +++ b/src/duckdb/src/include/duckdb/logging/logging.hpp @@ -0,0 +1,83 @@ +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/logging/log_storage.hpp +// +// +//===----------------------------------------------------------------------===// + +#pragma once + +#include "duckdb/common/atomic.hpp" +#include "duckdb/common/mutex.hpp" +#include "duckdb/common/optional_idx.hpp" +#include "duckdb/common/types.hpp" +#include "duckdb/common/unordered_set.hpp" +#include "duckdb/common/typedefs.hpp" + +namespace duckdb { + +// Note: `LOG_` prefix is to avoid problems with DEBUG and ERROR macros, these are ToString-ed without the prefix +enum class LogLevel : uint8_t { + LOG_TRACE = 10, + LOG_DEBUG = 20, + LOG_INFO = 30, + LOG_WARN = 40, + LOG_ERROR = 50, + LOG_FATAL = 60 +}; + +enum class LogContextScope : uint8_t { DATABASE = 10, CONNECTION = 20, THREAD = 30 }; + +enum class LogMode : uint8_t { LEVEL_ONLY = 0, DISABLE_SELECTED = 1, ENABLE_SELECTED = 2 }; + +struct LogConfig { + constexpr static const char *IN_MEMORY_STORAGE_NAME = "memory"; + constexpr static const char *STDOUT_STORAGE_NAME = "stdout"; + constexpr static const char *FILE_STORAGE_NAME = "file"; + + constexpr static LogLevel DEFAULT_LOG_LEVEL = LogLevel::LOG_INFO; + constexpr static const char *DEFAULT_LOG_STORAGE = IN_MEMORY_STORAGE_NAME; + + 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; + LogMode mode; + LogLevel level; + string storage; + + unordered_set enabled_log_types; + unordered_set disabled_log_types; + +protected: + LogConfig(bool enabled, LogLevel level, LogMode mode, optional_ptr> enabled_log_types, + optional_ptr> disable_loggers); +}; + +struct LoggingContext { + explicit LoggingContext(LogContextScope scope_p) : scope(scope_p) { + } + + LogContextScope scope; + + optional_idx thread; + optional_idx client_context; + optional_idx transaction_id; + + const char *default_log_type = "default"; +}; + +struct RegisteredLoggingContext { + idx_t context_id; + LoggingContext context; +}; + +} // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/main/client_config.hpp b/src/duckdb/src/include/duckdb/main/client_config.hpp index 8b919c821..304d844f0 100644 --- a/src/duckdb/src/include/duckdb/main/client_config.hpp +++ b/src/duckdb/src/include/duckdb/main/client_config.hpp @@ -120,7 +120,7 @@ struct ClientConfig { //! The maximum amount of OR filters we generate dynamically from a hash join idx_t dynamic_or_filter_threshold = 50; - //! Whether or not the "/" division operator defaults to integer division or floating point division + //! Whether the "/" division operator defaults to integer division or floating point division bool integer_division = false; //! When a scalar subquery returns multiple rows - return a random row instead of returning an error bool scalar_subquery_error_on_multiple_rows = true; diff --git a/src/duckdb/src/include/duckdb/main/client_context.hpp b/src/duckdb/src/include/duckdb/main/client_context.hpp index 6f5115cb1..ae0b93740 100644 --- a/src/duckdb/src/include/duckdb/main/client_context.hpp +++ b/src/duckdb/src/include/duckdb/main/client_context.hpp @@ -56,7 +56,7 @@ class RegisteredStateManager; struct PendingQueryParameters { //! Prepared statement parameters (if any) optional_ptr> parameters; - //! Whether or not a stream result should be allowed + //! Whether a stream result should be allowed bool allow_stream_result = false; }; @@ -80,6 +80,8 @@ class ClientContext : public enable_shared_from_this { atomic interrupted; //! Set of optional states (e.g. Caches) that can be held by the ClientContext unique_ptr registered_state; + //! The logger to be used by this ClientContext + unique_ptr logger; //! The client configuration ClientConfig config; //! The set of client-specific data @@ -199,13 +201,16 @@ class ClientContext : public enable_shared_from_this { //! Returns the current executor Executor &GetExecutor(); + //! Return the current logger + Logger &GetLogger() const; + //! Returns the current query string (if any) const string &GetCurrentQuery(); //! Fetch a list of table names that are required for a given query DUCKDB_API unordered_set GetTableNames(const string &query); - DUCKDB_API ClientProperties GetClientProperties() const; + DUCKDB_API ClientProperties GetClientProperties(); //! Returns true if execution of the current query is finished DUCKDB_API bool ExecutionIsFinished(); diff --git a/src/duckdb/src/include/duckdb/main/client_context_file_opener.hpp b/src/duckdb/src/include/duckdb/main/client_context_file_opener.hpp index 061ed8526..189d7dfd8 100644 --- a/src/duckdb/src/include/duckdb/main/client_context_file_opener.hpp +++ b/src/duckdb/src/include/duckdb/main/client_context_file_opener.hpp @@ -21,6 +21,7 @@ class ClientContextFileOpener : public FileOpener { explicit ClientContextFileOpener(ClientContext &context_p) : context(context_p) { } + Logger &GetLogger() const override; SettingLookupResult TryGetCurrentSetting(const string &key, Value &result, FileOpenerInfo &info) override; SettingLookupResult TryGetCurrentSetting(const string &key, Value &result) override; diff --git a/src/duckdb/src/include/duckdb/main/client_data.hpp b/src/duckdb/src/include/duckdb/main/client_data.hpp index b3e326267..49c281e2d 100644 --- a/src/duckdb/src/include/duckdb/main/client_data.hpp +++ b/src/duckdb/src/include/duckdb/main/client_data.hpp @@ -44,8 +44,9 @@ struct ClientData { //! The set of bound prepared statements that belong to this client case_insensitive_map_t> prepared_statements; - //! The writer used to log queries (if logging is enabled) + //! The writer used to log queries (if logging is enabled) TODO unify with new logger infra unique_ptr log_query_writer; + //! The random generator used by random(). Its seed value can be set by setseed(). unique_ptr random_engine; diff --git a/src/duckdb/src/include/duckdb/main/client_properties.hpp b/src/duckdb/src/include/duckdb/main/client_properties.hpp index 8619e8deb..a4038a735 100644 --- a/src/duckdb/src/include/duckdb/main/client_properties.hpp +++ b/src/duckdb/src/include/duckdb/main/client_properties.hpp @@ -8,6 +8,8 @@ #pragma once +#include + #include "duckdb/common/string.hpp" #include "duckdb/common/types.hpp" @@ -18,15 +20,18 @@ enum class ArrowOffsetSize : uint8_t { REGULAR, LARGE }; //! A set of properties from the client context that can be used to interpret the query result struct ClientProperties { ClientProperties(string time_zone_p, ArrowOffsetSize arrow_offset_size_p, bool arrow_use_list_view_p, - bool produce_arrow_string_view_p, bool lossless_conversion) + bool produce_arrow_string_view_p, bool lossless_conversion, + optional_ptr client_context) : time_zone(std::move(time_zone_p)), arrow_offset_size(arrow_offset_size_p), - arrow_use_list_view(arrow_use_list_view_p), arrow_lossless_conversion(lossless_conversion) { + arrow_use_list_view(arrow_use_list_view_p), produce_arrow_string_view(produce_arrow_string_view_p), + arrow_lossless_conversion(lossless_conversion), client_context(client_context) { } - ClientProperties() {}; + string time_zone = "UTC"; ArrowOffsetSize arrow_offset_size = ArrowOffsetSize::REGULAR; bool arrow_use_list_view = false; bool produce_arrow_string_view = false; bool arrow_lossless_conversion = false; + optional_ptr client_context; }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/main/config.hpp b/src/duckdb/src/include/duckdb/main/config.hpp index 604ef264b..27e4b4b0e 100644 --- a/src/duckdb/src/include/duckdb/main/config.hpp +++ b/src/duckdb/src/include/duckdb/main/config.hpp @@ -8,6 +8,8 @@ #pragma once +#include "duckdb/common/arrow/arrow_type_extension.hpp" + #include "duckdb/common/allocator.hpp" #include "duckdb/common/case_insensitive_map.hpp" #include "duckdb/common/cgroups.hpp" @@ -34,6 +36,7 @@ #include "duckdb/planner/operator_extension.hpp" #include "duckdb/storage/compression/bitpacking.hpp" #include "duckdb/function/encoding_function.hpp" +#include "duckdb/logging/log_manager.hpp" namespace duckdb { @@ -277,6 +280,8 @@ struct DBConfigOptions { unordered_set allowed_paths; //! Directories that are explicitly allowed, even if enable_external_access is false set allowed_directories; + //! The log configuration + LogConfig log_config = LogConfig(); bool operator==(const DBConfigOptions &other) const; }; @@ -366,9 +371,14 @@ struct DBConfig { //! Returns the encode function matching the encoding name. DUCKDB_API optional_ptr GetEncodeFunction(const string &name) const; DUCKDB_API void RegisterEncodeFunction(const EncodingFunction &function) const; - //! Returns the encode function names. DUCKDB_API vector> GetLoadedEncodedFunctions() const; + //! Returns the encode function matching the encoding name. + DUCKDB_API ArrowTypeExtension GetArrowExtension(ArrowExtensionMetadata info) const; + DUCKDB_API ArrowTypeExtension GetArrowExtension(const LogicalType &type) const; + DUCKDB_API bool HasArrowExtension(const LogicalType &type) const; + DUCKDB_API void RegisterArrowExtension(const ArrowTypeExtension &extension) const; + bool operator==(const DBConfig &other); bool operator!=(const DBConfig &other); @@ -405,6 +415,7 @@ struct DBConfig { private: unique_ptr compression_functions; unique_ptr encoding_functions; + unique_ptr arrow_extensions; unique_ptr cast_functions; unique_ptr collation_bindings; unique_ptr index_types; diff --git a/src/duckdb/src/include/duckdb/main/database.hpp b/src/duckdb/src/include/duckdb/main/database.hpp index 12bb6fbee..54884c563 100644 --- a/src/duckdb/src/include/duckdb/main/database.hpp +++ b/src/duckdb/src/include/duckdb/main/database.hpp @@ -8,13 +8,13 @@ #pragma once -#include "duckdb/main/config.hpp" -#include "duckdb/main/valid_checker.hpp" #include "duckdb/common/winapi.hpp" -#include "duckdb/main/extension.hpp" #include "duckdb/main/capi/extension_api.hpp" +#include "duckdb/main/config.hpp" +#include "duckdb/main/extension.hpp" #include "duckdb/main/extension_install_info.hpp" #include "duckdb/main/settings.hpp" +#include "duckdb/main/valid_checker.hpp" namespace duckdb { class BufferManager; @@ -30,6 +30,7 @@ struct AttachInfo; struct AttachOptions; class DatabaseFileSystem; struct DatabaseCacheEntry; +class LogManager; struct ExtensionInfo { bool is_loaded; @@ -57,6 +58,7 @@ class DatabaseInstance : public enable_shared_from_this { DUCKDB_API ObjectCache &GetObjectCache(); DUCKDB_API ConnectionManager &GetConnectionManager(); DUCKDB_API ValidChecker &GetValidChecker(); + DUCKDB_API LogManager &GetLogManager() const; DUCKDB_API void SetExtensionLoaded(const string &extension_name, ExtensionInstallInfo &install_info); DUCKDB_API const duckdb_ext_api_v1 GetExtensionAPIV1(); @@ -94,6 +96,7 @@ class DatabaseInstance : public enable_shared_from_this { ValidChecker db_validity; unique_ptr db_file_system; shared_ptr db_cache_entry; + shared_ptr log_manager; duckdb_ext_api_v1 (*create_api_v1)(); }; diff --git a/src/duckdb/src/include/duckdb/main/database_file_opener.hpp b/src/duckdb/src/include/duckdb/main/database_file_opener.hpp index 024956aaa..ae61f9272 100644 --- a/src/duckdb/src/include/duckdb/main/database_file_opener.hpp +++ b/src/duckdb/src/include/duckdb/main/database_file_opener.hpp @@ -21,6 +21,10 @@ class DatabaseFileOpener : public FileOpener { explicit DatabaseFileOpener(DatabaseInstance &db_p) : db(db_p) { } + Logger &GetLogger() const override { + return Logger::Get(db); + } + SettingLookupResult TryGetCurrentSetting(const string &key, Value &result) override { return db.TryGetCurrentSetting(key, result); } diff --git a/src/duckdb/src/include/duckdb/main/settings.hpp b/src/duckdb/src/include/duckdb/main/settings.hpp index 4e89c3416..98d4d4eb4 100644 --- a/src/duckdb/src/include/duckdb/main/settings.hpp +++ b/src/duckdb/src/include/duckdb/main/settings.hpp @@ -429,6 +429,16 @@ struct DisabledFilesystemsSetting { static Value GetSetting(const ClientContext &context); }; +struct DisabledLogTypes { + using RETURN_TYPE = string; + static constexpr const char *Name = "disabled_log_types"; + static constexpr const char *Description = "Sets the list of disabled loggers"; + 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); +}; + struct DisabledOptimizersSetting { using RETURN_TYPE = string; static constexpr const char *Name = "disabled_optimizers"; @@ -505,6 +515,16 @@ struct EnableHTTPMetadataCacheSetting { static Value GetSetting(const ClientContext &context); }; +struct EnableLogging { + using RETURN_TYPE = bool; + static constexpr const char *Name = "enable_logging"; + static constexpr const char *Description = "Enables the logger"; + 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); +}; + struct EnableMacroDependenciesSetting { using RETURN_TYPE = bool; static constexpr const char *Name = "enable_macro_dependencies"; @@ -572,6 +592,16 @@ struct EnableViewDependenciesSetting { static Value GetSetting(const ClientContext &context); }; +struct EnabledLogTypes { + using RETURN_TYPE = string; + static constexpr const char *Name = "enabled_log_types"; + static constexpr const char *Description = "Sets the list of enabled loggers"; + 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); +}; + struct ErrorsAsJSONSetting { using RETURN_TYPE = bool; static constexpr const char *Name = "errors_as_json"; @@ -774,6 +804,36 @@ struct LogQueryPathSetting { static Value GetSetting(const ClientContext &context); }; +struct LoggingLevel { + using RETURN_TYPE = string; + static constexpr const char *Name = "logging_level"; + static constexpr const char *Description = "The log level which will be recorded in the log"; + 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); +}; + +struct LoggingMode { + using RETURN_TYPE = string; + static constexpr const char *Name = "logging_mode"; + static constexpr const char *Description = "Enables the logger"; + 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); +}; + +struct LoggingStorage { + using RETURN_TYPE = string; + static constexpr const char *Name = "logging_storage"; + static constexpr const char *Description = "Set the logging storage (memory/stdout/file)"; + 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); +}; + struct MaxExpressionDepthSetting { using RETURN_TYPE = idx_t; static constexpr const char *Name = "max_expression_depth"; diff --git a/src/duckdb/src/include/duckdb/parallel/event.hpp b/src/duckdb/src/include/duckdb/parallel/event.hpp index f259cf55a..768d9d19b 100644 --- a/src/duckdb/src/include/duckdb/parallel/event.hpp +++ b/src/duckdb/src/include/duckdb/parallel/event.hpp @@ -8,6 +8,7 @@ #pragma once +#include "duckdb/execution/executor.hpp" #include "duckdb/common/atomic.hpp" #include "duckdb/common/common.hpp" #include "duckdb/common/vector.hpp" @@ -52,6 +53,8 @@ class Event : public enable_shared_from_this { virtual void PrintPipeline() { } + ClientContext &GetClientContext(); + template TARGET &Cast() { DynamicCastCheck(this); diff --git a/src/duckdb/src/include/duckdb/parallel/thread_context.hpp b/src/duckdb/src/include/duckdb/parallel/thread_context.hpp index 90097e7f0..191303145 100644 --- a/src/duckdb/src/include/duckdb/parallel/thread_context.hpp +++ b/src/duckdb/src/include/duckdb/parallel/thread_context.hpp @@ -12,14 +12,17 @@ namespace duckdb { class ClientContext; +class Logger; //! The ThreadContext holds thread-local info for parallel usage class ThreadContext { public: explicit ThreadContext(ClientContext &context); + ~ThreadContext(); //! The operator profiler for the individual thread context OperatorProfiler profiler; + unique_ptr logger; }; } // namespace duckdb diff --git a/src/duckdb/src/logging/log_manager.cpp b/src/duckdb/src/logging/log_manager.cpp new file mode 100644 index 000000000..2a2aaae86 --- /dev/null +++ b/src/duckdb/src/logging/log_manager.cpp @@ -0,0 +1,155 @@ +#include "duckdb/logging/log_manager.hpp" +#include "duckdb/logging/log_storage.hpp" +#include "duckdb/main/database.hpp" +#include "duckdb/main/client_context.hpp" +#include "duckdb/main/client_data.hpp" + +namespace duckdb { + +unique_ptr LogManager::CreateLogger(LoggingContext context, bool thread_safe, bool mutable_settings) { + unique_lock lck(lock); + + auto registered_logging_context = RegisterLoggingContextInternal(context); + + if (mutable_settings) { + return make_uniq(config, registered_logging_context, *this); + } + if (!config.enabled) { + return make_uniq(*this); + } + if (!thread_safe) { + // TODO: implement ThreadLocalLogger and return it here + } + return make_uniq(config, registered_logging_context, *this); +} + +RegisteredLoggingContext LogManager::RegisterLoggingContext(LoggingContext &context) { + unique_lock lck(lock); + + return RegisterLoggingContextInternal(context); +} + +bool LogManager::RegisterLogStorage(const string &name, shared_ptr &storage) { + if (registered_log_storages.find(name) != registered_log_storages.end()) { + return false; + } + registered_log_storages.insert({name, std::move(storage)}); + return true; +} + +Logger &LogManager::GlobalLogger() { + return *global_logger; +} + +void LogManager::Flush() { + unique_lock lck(lock); + log_storage->Flush(); +} + +shared_ptr LogManager::GetLogStorage() { + unique_lock lck(lock); + return log_storage; +} + +bool LogManager::CanScan() { + unique_lock lck(lock); + return log_storage->CanScan(); +} + +LogManager::LogManager(DatabaseInstance &db, LogConfig config_p) : config(std::move(config_p)) { + log_storage = make_uniq(db); +} + +LogManager::~LogManager() { +} + +void LogManager::Initialize() { + LoggingContext context(LogContextScope::DATABASE); + global_logger = CreateLogger(context, true, true); +} + +LogManager &LogManager::Get(ClientContext &context) { + return context.db->GetLogManager(); +} + +RegisteredLoggingContext LogManager::RegisterLoggingContextInternal(LoggingContext &context) { + RegisteredLoggingContext result = {next_registered_logging_context_index, context}; + + next_registered_logging_context_index += 1; + + if (next_registered_logging_context_index == NumericLimits::Maximum()) { + throw InternalException("Ran out of available log context ids."); + } + + return result; +} + +void LogManager::WriteLogEntry(timestamp_t timestamp, const char *log_type, LogLevel log_level, const char *log_message, + const RegisteredLoggingContext &context) { + unique_lock lck(lock); + log_storage->WriteLogEntry(timestamp, log_level, log_type, log_message, context); +} + +void LogManager::FlushCachedLogEntries(DataChunk &chunk, const RegisteredLoggingContext &context) { + throw NotImplementedException("FlushCachedLogEntries"); +} + +void LogManager::SetEnableLogging(bool enable) { + unique_lock lck(lock); + config.enabled = enable; + global_logger->UpdateConfig(config); +} + +void LogManager::SetLogMode(LogMode mode) { + unique_lock lck(lock); + config.mode = mode; + global_logger->UpdateConfig(config); +} + +void LogManager::SetLogLevel(LogLevel level) { + unique_lock lck(lock); + config.level = level; + global_logger->UpdateConfig(config); +} + +void LogManager::SetEnabledLogTypes(unordered_set &enabled_log_types) { + unique_lock lck(lock); + config.enabled_log_types = enabled_log_types; + global_logger->UpdateConfig(config); +} + +void LogManager::SetDisabledLogTypes(unordered_set &disabled_log_types) { + unique_lock lck(lock); + config.disabled_log_types = disabled_log_types; + global_logger->UpdateConfig(config); +} + +void LogManager::SetLogStorage(DatabaseInstance &db, const string &storage_name) { + unique_lock lck(lock); + auto storage_name_to_lower = StringUtil::Lower(storage_name); + + if (config.storage == storage_name_to_lower) { + return; + } + + // Flush the old storage, we are going to replace it. + log_storage->Flush(); + + if (storage_name_to_lower == LogConfig::IN_MEMORY_STORAGE_NAME) { + log_storage = make_shared_ptr(db); + } else if (storage_name_to_lower == LogConfig::STDOUT_STORAGE_NAME) { + log_storage = make_shared_ptr(); + } else if (storage_name_to_lower == LogConfig::FILE_STORAGE_NAME) { + throw NotImplementedException("File log storage is not yet implemented"); + } else if (registered_log_storages.find(storage_name_to_lower) != registered_log_storages.end()) { + log_storage = registered_log_storages[storage_name_to_lower]; + } + config.storage = storage_name_to_lower; +} + +LogConfig LogManager::GetConfig() { + unique_lock lck(lock); + return config; +} + +} // namespace duckdb diff --git a/src/duckdb/src/logging/log_storage.cpp b/src/duckdb/src/logging/log_storage.cpp new file mode 100644 index 000000000..909bddf75 --- /dev/null +++ b/src/duckdb/src/logging/log_storage.cpp @@ -0,0 +1,209 @@ +#include "duckdb/logging/log_storage.hpp" +#include "duckdb/logging/logging.hpp" +#include "duckdb/main/database.hpp" +#include "duckdb/main/client_context.hpp" + +#include + +namespace duckdb { + +unique_ptr LogStorage::CreateScanEntriesState() const { + throw NotImplementedException("Not implemented for this LogStorage: CreateScanEntriesState"); +} +bool LogStorage::ScanEntries(LogStorageScanState &state, DataChunk &result) const { + throw NotImplementedException("Not implemented for this LogStorage: ScanEntries"); +} +void LogStorage::InitializeScanEntries(LogStorageScanState &state) const { + throw NotImplementedException("Not implemented for this LogStorage: InitializeScanEntries"); +} +unique_ptr LogStorage::CreateScanContextsState() const { + throw NotImplementedException("Not implemented for this LogStorage: CreateScanContextsState"); +} +bool LogStorage::ScanContexts(LogStorageScanState &state, DataChunk &result) const { + throw NotImplementedException("Not implemented for this LogStorage: ScanContexts"); +} +void LogStorage::InitializeScanContexts(LogStorageScanState &state) const { + throw NotImplementedException("Not implemented for this LogStorage: InitializeScanContexts"); +} + +StdOutLogStorage::StdOutLogStorage() { +} + +StdOutLogStorage::~StdOutLogStorage() { +} + +void StdOutLogStorage::WriteLogEntry(timestamp_t timestamp, LogLevel level, const string &log_type, + const string &log_message, const RegisteredLoggingContext &context) { + std::cout << StringUtil::Format( + "[LOG] %s, %s, %s, %s, %s, %s, %s, %s\n", Value::TIMESTAMP(timestamp).ToString(), log_type, + EnumUtil::ToString(level), log_message, EnumUtil::ToString(context.context.scope), + context.context.client_context.IsValid() ? to_string(context.context.client_context.GetIndex()) : "NULL", + context.context.transaction_id.IsValid() ? to_string(context.context.transaction_id.GetIndex()) : "NULL", + context.context.thread.IsValid() ? to_string(context.context.thread.GetIndex()) : "NULL"); +} + +void StdOutLogStorage::WriteLogEntries(DataChunk &chunk, const RegisteredLoggingContext &context) { + throw NotImplementedException("StdOutLogStorage::WriteLogEntries"); +} + +void StdOutLogStorage::Flush() { + // NOP +} + +InMemoryLogStorageScanState::InMemoryLogStorageScanState() { +} +InMemoryLogStorageScanState::~InMemoryLogStorageScanState() { +} + +InMemoryLogStorage::InMemoryLogStorage(DatabaseInstance &db_p) + : entry_buffer(make_uniq()), log_context_buffer(make_uniq()) { + // LogEntry Schema + vector log_entry_schema = { + LogicalType::UBIGINT, // context_id + LogicalType::TIMESTAMP, // timestamp + LogicalType::VARCHAR, // log_type TODO: const vector where possible? + LogicalType::VARCHAR, // level TODO: enumify + LogicalType::VARCHAR, // message + }; + + // LogContext Schema + vector log_context_schema = { + LogicalType::UBIGINT, // context_id + LogicalType::VARCHAR, // scope TODO: enumify + LogicalType::UBIGINT, // client_context + LogicalType::UBIGINT, // transaction_id + LogicalType::UBIGINT, // thread + }; + + max_buffer_size = STANDARD_VECTOR_SIZE; + entry_buffer->Initialize(Allocator::DefaultAllocator(), log_entry_schema, max_buffer_size); + log_context_buffer->Initialize(Allocator::DefaultAllocator(), log_context_schema, max_buffer_size); + log_entries = make_uniq(db_p.GetBufferManager(), log_entry_schema); + log_contexts = make_uniq(db_p.GetBufferManager(), log_context_schema); +} + +InMemoryLogStorage::~InMemoryLogStorage() { +} + +void InMemoryLogStorage::WriteLogEntry(timestamp_t timestamp, LogLevel level, const string &log_type, + const string &log_message, const RegisteredLoggingContext &context) { + unique_lock lck(lock); + + if (registered_contexts.find(context.context_id) == registered_contexts.end()) { + WriteLoggingContext(context); + } + + auto size = entry_buffer->size(); + auto context_id_data = FlatVector::GetData(entry_buffer->data[0]); + auto timestamp_data = FlatVector::GetData(entry_buffer->data[1]); + auto type_data = FlatVector::GetData(entry_buffer->data[2]); + auto level_data = FlatVector::GetData(entry_buffer->data[3]); + auto message_data = FlatVector::GetData(entry_buffer->data[4]); + + context_id_data[size] = context.context_id; + timestamp_data[size] = timestamp; + type_data[size] = StringVector::AddString(entry_buffer->data[2], log_type); + level_data[size] = StringVector::AddString(entry_buffer->data[3], EnumUtil::ToString(level)); + message_data[size] = StringVector::AddString(entry_buffer->data[4], log_message); + + entry_buffer->SetCardinality(size + 1); + + if (size + 1 >= max_buffer_size) { + FlushInternal(); + } +} + +void InMemoryLogStorage::WriteLogEntries(DataChunk &chunk, const RegisteredLoggingContext &context) { + log_entries->Append(chunk); +} + +void InMemoryLogStorage::Flush() { + unique_lock lck(lock); + FlushInternal(); +} + +void InMemoryLogStorage::FlushInternal() { + if (entry_buffer->size() > 0) { + log_entries->Append(*entry_buffer); + entry_buffer->Reset(); + } + + if (log_context_buffer->size() > 0) { + log_contexts->Append(*log_context_buffer); + log_context_buffer->Reset(); + } +} + +void InMemoryLogStorage::WriteLoggingContext(const RegisteredLoggingContext &context) { + registered_contexts.insert(context.context_id); + + auto size = log_context_buffer->size(); + + auto context_id_data = FlatVector::GetData(log_context_buffer->data[0]); + context_id_data[size] = context.context_id; + + auto context_scope_data = FlatVector::GetData(log_context_buffer->data[1]); + context_scope_data[size] = + StringVector::AddString(log_context_buffer->data[1], EnumUtil::ToString(context.context.scope)); + + if (context.context.client_context.IsValid()) { + auto client_context_data = FlatVector::GetData(log_context_buffer->data[2]); + client_context_data[size] = context.context.client_context.GetIndex(); + } else { + FlatVector::Validity(log_context_buffer->data[2]).SetInvalid(size); + } + if (context.context.transaction_id.IsValid()) { + auto client_context_data = FlatVector::GetData(log_context_buffer->data[3]); + client_context_data[size] = context.context.transaction_id.GetIndex(); + } else { + FlatVector::Validity(log_context_buffer->data[3]).SetInvalid(size); + } + if (context.context.thread.IsValid()) { + auto thread_data = FlatVector::GetData(log_context_buffer->data[4]); + thread_data[size] = context.context.thread.GetIndex(); + } else { + FlatVector::Validity(log_context_buffer->data[4]).SetInvalid(size); + } + + log_context_buffer->SetCardinality(size + 1); + + if (size + 1 >= max_buffer_size) { + FlushInternal(); + } +} + +bool InMemoryLogStorage::CanScan() { + return true; +} + +unique_ptr InMemoryLogStorage::CreateScanEntriesState() const { + return make_uniq(); +} +bool InMemoryLogStorage::ScanEntries(LogStorageScanState &state, DataChunk &result) const { + unique_lock lck(lock); + auto &in_mem_scan_state = state.Cast(); + return log_entries->Scan(in_mem_scan_state.scan_state, result); +} + +void InMemoryLogStorage::InitializeScanEntries(LogStorageScanState &state) const { + unique_lock lck(lock); + auto &in_mem_scan_state = state.Cast(); + log_entries->InitializeScan(in_mem_scan_state.scan_state, ColumnDataScanProperties::DISALLOW_ZERO_COPY); +} + +unique_ptr InMemoryLogStorage::CreateScanContextsState() const { + return make_uniq(); +} +bool InMemoryLogStorage::ScanContexts(LogStorageScanState &state, DataChunk &result) const { + unique_lock lck(lock); + auto &in_mem_scan_state = state.Cast(); + return log_contexts->Scan(in_mem_scan_state.scan_state, result); +} + +void InMemoryLogStorage::InitializeScanContexts(LogStorageScanState &state) const { + unique_lock lck(lock); + auto &in_mem_scan_state = state.Cast(); + log_contexts->InitializeScan(in_mem_scan_state.scan_state, ColumnDataScanProperties::DISALLOW_ZERO_COPY); +} + +} // namespace duckdb diff --git a/src/duckdb/src/logging/logger.cpp b/src/duckdb/src/logging/logger.cpp new file mode 100644 index 000000000..03af3437b --- /dev/null +++ b/src/duckdb/src/logging/logger.cpp @@ -0,0 +1,211 @@ +#include "duckdb/logging/log_storage.hpp" +#include "duckdb/logging/log_manager.hpp" + +#include "duckdb/main/client_context.hpp" +#include "duckdb/main/connection.hpp" +#include "duckdb/main/database.hpp" +#include "duckdb/common/file_opener.hpp" +#include "duckdb/parallel/thread_context.hpp" + +namespace duckdb { + +Logger &Logger::Get(const DatabaseInstance &db) { + return db.GetLogManager().GlobalLogger(); +} + +Logger &Logger::Get(const ThreadContext &thread_context) { + return *thread_context.logger; +} + +Logger &Logger::Get(const ExecutionContext &execution_context) { + return *execution_context.thread.logger; +} + +Logger &Logger::Get(const ClientContext &client_context) { + return client_context.GetLogger(); +} + +Logger &Logger::Get(const FileOpener &opener) { + return opener.GetLogger(); +} + +void Logger::Log(const char *log_type, LogLevel log_level, const char *log_message) { + if (ShouldLog(log_type, log_level)) { + WriteLog(log_type, log_level, log_message); + } +} + +void Logger::Log(LogLevel log_level, const char *log_message) { + if (ShouldLog(log_level)) { + WriteLog(log_level, log_message); + } +} + +void Logger::Log(const char *log_type, LogLevel log_level, const string_t &log_message) { + if (ShouldLog(log_type, log_level)) { + auto string_copy = log_message.GetString(); + WriteLog(log_type, log_level, string_copy.c_str()); + } +} + +void Logger::Log(LogLevel log_level, const string_t &log_message) { + if (ShouldLog(log_level)) { + auto string_copy = log_message.GetString(); + WriteLog(log_level, string_copy.c_str()); + } +} + +void Logger::Log(const char *log_type, LogLevel log_level, std::function callback) { // NOLINT + if (ShouldLog(log_type, log_level)) { + auto string = callback(); + WriteLog(log_type, log_level, string.c_str()); + } +} + +void Logger::Log(LogLevel log_level, std::function callback) { // NOLINT + if (ShouldLog(log_level)) { + auto string = callback(); + WriteLog(log_level, string.c_str()); + } +} + +ThreadSafeLogger::ThreadSafeLogger(LogConfig &config_p, LoggingContext &context_p, LogManager &manager) + : ThreadSafeLogger(config_p, manager.RegisterLoggingContext(context_p), manager) { +} + +ThreadSafeLogger::ThreadSafeLogger(LogConfig &config_p, RegisteredLoggingContext context_p, LogManager &manager) + : Logger(manager), config(config_p), context(context_p) { + // NopLogger should be used instead + D_ASSERT(config_p.enabled); +} + +bool ThreadSafeLogger::ShouldLog(const char *log_type, LogLevel log_level) { + if (config.level > log_level) { + return false; + } + + // TODO: improve these: they are currently fairly expensive due to requiring allocations when looking up const char* + // also, we would ideally do prefix matching, not string matching here + if (config.mode == LogMode::ENABLE_SELECTED) { + return config.enabled_log_types.find(log_type) != config.enabled_log_types.end(); + } + if (config.mode == LogMode::DISABLE_SELECTED) { + return config.disabled_log_types.find(log_type) == config.disabled_log_types.end(); + } + return true; +} + +bool ThreadSafeLogger::ShouldLog(LogLevel log_level) { + return ShouldLog(context.context.default_log_type, log_level); +} + +void ThreadSafeLogger::WriteLog(const char *log_type, LogLevel log_level, const char *log_message) { + manager.WriteLogEntry(Timestamp::GetCurrentTimestamp(), log_type, log_level, log_message, context); +} + +void ThreadSafeLogger::WriteLog(LogLevel log_level, const char *log_message) { + manager.WriteLogEntry(Timestamp::GetCurrentTimestamp(), context.context.default_log_type, log_level, log_message, + context); +} + +void ThreadSafeLogger::Flush() { + manager.Flush(); + // NOP +} + +ThreadLocalLogger::ThreadLocalLogger(LogConfig &config_p, LoggingContext &context_p, LogManager &manager) + : ThreadLocalLogger(config_p, manager.RegisterLoggingContext(context_p), manager) { +} + +ThreadLocalLogger::ThreadLocalLogger(LogConfig &config_p, RegisteredLoggingContext context_p, LogManager &manager) + : Logger(manager), config(config_p), context(context_p) { + // NopLogger should be used instead + D_ASSERT(config_p.enabled); +} + +bool ThreadLocalLogger::ShouldLog(const char *log_type, LogLevel log_level) { + throw NotImplementedException("ThreadLocalLogger::ShouldLog"); +} + +bool ThreadLocalLogger::ShouldLog(LogLevel log_level) { + throw NotImplementedException("ThreadLocalLogger::ShouldLog"); +} + +void ThreadLocalLogger::WriteLog(const char *log_type, LogLevel log_level, const char *log_message) { + throw NotImplementedException("ThreadLocalLogger::WriteLog"); +} + +void ThreadLocalLogger::WriteLog(LogLevel log_level, const char *log_message) { + throw NotImplementedException("ThreadLocalLogger::WriteLog"); +} + +void ThreadLocalLogger::Flush() { + manager.Flush(); +} + +MutableLogger::MutableLogger(LogConfig &config_p, LoggingContext &context_p, LogManager &manager) + : MutableLogger(config_p, manager.RegisterLoggingContext(context_p), manager) { +} + +MutableLogger::MutableLogger(LogConfig &config_p, RegisteredLoggingContext context_p, LogManager &manager) + : Logger(manager), config(config_p), context(context_p) { + enabled = config.enabled; + level = config.level; + mode = config.mode; +} + +void MutableLogger::UpdateConfig(LogConfig &new_config) { + unique_lock lck(lock); + config = new_config; + + // Update atomics for lock-free access + enabled = config.enabled; + level = config.level; + mode = config.mode; +} + +void MutableLogger::WriteLog(const char *log_type, LogLevel log_level, const char *log_message) { + manager.WriteLogEntry(Timestamp::GetCurrentTimestamp(), log_type, log_level, log_message, context); +} + +void MutableLogger::WriteLog(LogLevel log_level, const char *log_message) { + manager.WriteLogEntry(Timestamp::GetCurrentTimestamp(), context.context.default_log_type, log_level, log_message, + context); +} + +bool MutableLogger::ShouldLog(const char *log_type, LogLevel log_level) { + if (!enabled) { + return false; + } + + // check atomic level to early out if level too low + if (level > log_level) { + return false; + } + + if (mode == LogMode::LEVEL_ONLY) { + return true; + } + + // FIXME: ENABLE_SELECTED and DISABLE_SELECTED are expensive and need full global lock + { + unique_lock lck(lock); + if (config.mode == LogMode::ENABLE_SELECTED) { + return config.enabled_log_types.find(log_type) != config.enabled_log_types.end(); + } + if (config.mode == LogMode::DISABLE_SELECTED) { + return config.disabled_log_types.find(log_type) == config.disabled_log_types.end(); + } + } + throw InternalException("Should be unreachable (MutableLogger::ShouldLog)"); +} + +bool MutableLogger::ShouldLog(LogLevel log_level) { + return ShouldLog(context.context.default_log_type, log_level); +} + +void MutableLogger::Flush() { + manager.Flush(); +} + +} // namespace duckdb diff --git a/src/duckdb/src/logging/logging.cpp b/src/duckdb/src/logging/logging.cpp new file mode 100644 index 000000000..b0a614627 --- /dev/null +++ b/src/duckdb/src/logging/logging.cpp @@ -0,0 +1,42 @@ +#include "duckdb/logging/log_storage.hpp" +#include "duckdb/logging/logger.hpp" + +namespace duckdb { + +LogConfig::LogConfig() + : enabled(false), mode(LogMode::LEVEL_ONLY), level(DEFAULT_LOG_LEVEL), storage(DEFAULT_LOG_STORAGE) { +} + +bool LogConfig::IsConsistent() const { + if (mode == LogMode::LEVEL_ONLY) { + return enabled_log_types.empty() && disabled_log_types.empty(); + } + if (mode == LogMode::DISABLE_SELECTED) { + return enabled_log_types.empty() && !disabled_log_types.empty(); + } + if (mode == LogMode::ENABLE_SELECTED) { + return !enabled_log_types.empty() && disabled_log_types.empty(); + } + 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) + : enabled(enabled), mode(mode_p), level(level_p), enabled_log_types(enabled_log_types_p), + disabled_log_types(disabled_log_types_p) { + storage = LogConfig::IN_MEMORY_STORAGE_NAME; +} + +} // namespace duckdb diff --git a/src/duckdb/src/main/capi/arrow-c.cpp b/src/duckdb/src/main/capi/arrow-c.cpp index f74d9e22f..ab567393e 100644 --- a/src/duckdb/src/main/capi/arrow-c.cpp +++ b/src/duckdb/src/main/capi/arrow-c.cpp @@ -52,11 +52,11 @@ duckdb_state duckdb_prepared_arrow_schema(duckdb_prepared_statement prepared, du for (idx_t i = 0; i < count; i++) { // Every prepared parameter type is UNKNOWN, which we need to map to NULL according to the spec of // 'AdbcStatementGetParameterSchema' - auto type = LogicalType::SQLNULL; + const auto type = LogicalType::SQLNULL; // FIXME: we don't support named parameters yet, but when we do, this needs to be updated auto name = std::to_string(i); - prepared_types.push_back(std::move(type)); + prepared_types.push_back(type); prepared_names.push_back(name); } @@ -87,8 +87,10 @@ duckdb_state duckdb_query_arrow_array(duckdb_arrow result, duckdb_arrow_array *o if (!wrapper->current_chunk || wrapper->current_chunk->size() == 0) { return DuckDBSuccess; } + auto extension_type_cast = duckdb::ArrowTypeExtensionData::GetExtensionTypes( + *wrapper->result->client_properties.client_context, wrapper->result->types); ArrowConverter::ToArrowArray(*wrapper->current_chunk, reinterpret_cast(*out_array), - wrapper->result->client_properties); + wrapper->result->client_properties, extension_type_cast); return DuckDBSuccess; } @@ -98,8 +100,11 @@ void duckdb_result_arrow_array(duckdb_result result, duckdb_data_chunk chunk, du } auto dchunk = reinterpret_cast(chunk); auto &result_data = *(reinterpret_cast(result.internal_data)); + auto extension_type_cast = duckdb::ArrowTypeExtensionData::GetExtensionTypes( + *result_data.result->client_properties.client_context, result_data.result->types); + ArrowConverter::ToArrowArray(*dchunk, reinterpret_cast(*out_array), - result_data.result->client_properties); + result_data.result->client_properties, extension_type_cast); } idx_t duckdb_arrow_row_count(duckdb_arrow result) { diff --git a/src/duckdb/src/main/capi/helper-c.cpp b/src/duckdb/src/main/capi/helper-c.cpp index 710996537..310ddc0d0 100644 --- a/src/duckdb/src/main/capi/helper-c.cpp +++ b/src/duckdb/src/main/capi/helper-c.cpp @@ -74,6 +74,8 @@ LogicalTypeId ConvertCTypeToCPP(duckdb_type c_type) { return LogicalTypeId::TIMESTAMP_TZ; case DUCKDB_TYPE_ANY: return LogicalTypeId::ANY; + case DUCKDB_TYPE_VARINT: + return LogicalTypeId::VARINT; case DUCKDB_TYPE_SQLNULL: return LogicalTypeId::SQLNULL; default: // LCOV_EXCL_START diff --git a/src/duckdb/src/main/client_context.cpp b/src/duckdb/src/main/client_context.cpp index 53234bdb9..58c576c52 100644 --- a/src/duckdb/src/main/client_context.cpp +++ b/src/duckdb/src/main/client_context.cpp @@ -138,11 +138,15 @@ struct DebugClientContextState : public ClientContextState { #endif ClientContext::ClientContext(shared_ptr database) - : db(std::move(database)), interrupted(false), client_data(make_uniq(*this)), transaction(*this) { + : db(std::move(database)), interrupted(false), transaction(*this) { registered_state = make_uniq(); #ifdef DEBUG registered_state->GetOrCreate("debug_client_context_state"); #endif + LoggingContext context(LogContextScope::CONNECTION); + context.client_context = reinterpret_cast(this); + logger = db->GetLogManager().CreateLogger(context, true); + client_data = make_uniq(*this); } ClientContext::~ClientContext() { @@ -205,6 +209,16 @@ void ClientContext::BeginQueryInternal(ClientContextLock &lock, const string &qu for (auto &state : registered_state->States()) { state->QueryBegin(*this); } + + // Flush the old Logger + logger->Flush(); + + // Refresh the logger to ensure we are in sync with global log settings + LoggingContext context(LogContextScope::CONNECTION); + context.client_context = reinterpret_cast(this); + context.transaction_id = transaction.GetActiveQuery(); + logger = db->GetLogManager().CreateLogger(context, true); + Logger::Info("duckdb.ClientContext.BeginQuery", *this, query); } ErrorData ClientContext::EndQueryInternal(ClientContextLock &lock, bool success, bool invalidate_transaction, @@ -215,7 +229,6 @@ ErrorData ClientContext::EndQueryInternal(ClientContextLock &lock, bool success, active_query->executor->CancelTasks(); } active_query->progress_bar.reset(); - D_ASSERT(active_query.get()); active_query.reset(); query_progress.Initialize(); @@ -244,6 +257,12 @@ ErrorData ClientContext::EndQueryInternal(ClientContextLock &lock, bool success, error = ErrorData("Unhandled exception!"); } // LCOV_EXCL_STOP + // Refresh the logger + logger->Flush(); + LoggingContext context(LogContextScope::CONNECTION); + context.client_context = reinterpret_cast(this); + logger = db->GetLogManager().CreateLogger(context, true); + // Notify any registered state of query end for (auto const &s : registered_state->States()) { if (error.HasError()) { @@ -288,6 +307,10 @@ Executor &ClientContext::GetExecutor() { return *active_query->executor; } +Logger &ClientContext::GetLogger() const { + return *logger; +} + const string &ClientContext::GetCurrentQuery() { D_ASSERT(active_query); return active_query->query; @@ -1343,15 +1366,19 @@ ParserOptions ClientContext::GetParserOptions() const { return options; } -ClientProperties ClientContext::GetClientProperties() const { +ClientProperties ClientContext::GetClientProperties() { string timezone = "UTC"; Value result; if (TryGetCurrentSetting("TimeZone", result)) { timezone = result.ToString(); } - return {timezone, db->config.options.arrow_offset_size, db->config.options.arrow_use_list_view, - db->config.options.produce_arrow_string_views, db->config.options.arrow_lossless_conversion}; + return {timezone, + db->config.options.arrow_offset_size, + db->config.options.arrow_use_list_view, + db->config.options.produce_arrow_string_views, + db->config.options.arrow_lossless_conversion, + this}; } bool ClientContext::ExecutionIsFinished() { diff --git a/src/duckdb/src/main/client_context_file_opener.cpp b/src/duckdb/src/main/client_context_file_opener.cpp index 5c7387b86..f7a85dc7c 100644 --- a/src/duckdb/src/main/client_context_file_opener.cpp +++ b/src/duckdb/src/main/client_context_file_opener.cpp @@ -11,6 +11,10 @@ SettingLookupResult ClientContextFileOpener::TryGetCurrentSetting(const string & return context.TryGetCurrentSetting(key, result); } +Logger &ClientContextFileOpener::GetLogger() const { + return Logger::Get(context); +} + // LCOV_EXCL_START SettingLookupResult ClientContextFileOpener::TryGetCurrentSetting(const string &key, Value &result, FileOpenerInfo &) { return context.TryGetCurrentSetting(key, result); diff --git a/src/duckdb/src/main/config.cpp b/src/duckdb/src/main/config.cpp index 2c604cec3..286c72a3c 100644 --- a/src/duckdb/src/main/config.cpp +++ b/src/duckdb/src/main/config.cpp @@ -93,6 +93,7 @@ static const ConfigurationOption internal_options[] = { DUCKDB_GLOBAL(DefaultOrderSetting), DUCKDB_GLOBAL(DefaultSecretStorageSetting), DUCKDB_GLOBAL(DisabledFilesystemsSetting), + DUCKDB_GLOBAL(DisabledLogTypes), DUCKDB_GLOBAL(DisabledOptimizersSetting), DUCKDB_GLOBAL(DuckDBAPISetting), DUCKDB_LOCAL(DynamicOrFilterThresholdSetting), @@ -100,12 +101,14 @@ static const ConfigurationOption internal_options[] = { DUCKDB_GLOBAL(EnableFSSTVectorsSetting), DUCKDB_LOCAL(EnableHTTPLoggingSetting), DUCKDB_GLOBAL(EnableHTTPMetadataCacheSetting), + DUCKDB_GLOBAL(EnableLogging), DUCKDB_GLOBAL(EnableMacroDependenciesSetting), DUCKDB_GLOBAL(EnableObjectCacheSetting), DUCKDB_LOCAL(EnableProfilingSetting), DUCKDB_LOCAL(EnableProgressBarSetting), DUCKDB_LOCAL(EnableProgressBarPrintSetting), DUCKDB_GLOBAL(EnableViewDependenciesSetting), + DUCKDB_GLOBAL(EnabledLogTypes), DUCKDB_LOCAL(ErrorsAsJSONSetting), DUCKDB_LOCAL(ExplainOutputSetting), DUCKDB_GLOBAL(ExtensionDirectorySetting), @@ -125,6 +128,9 @@ static const ConfigurationOption internal_options[] = { DUCKDB_LOCAL(IntegerDivisionSetting), DUCKDB_GLOBAL(LockConfigurationSetting), DUCKDB_LOCAL(LogQueryPathSetting), + DUCKDB_GLOBAL(LoggingLevel), + DUCKDB_GLOBAL(LoggingMode), + DUCKDB_GLOBAL(LoggingStorage), DUCKDB_LOCAL(MaxExpressionDepthSetting), DUCKDB_GLOBAL(MaxMemorySetting), DUCKDB_GLOBAL_ALIAS("memory_limit", MaxMemorySetting), diff --git a/src/duckdb/src/main/database.cpp b/src/duckdb/src/main/database.cpp index 3bd387f84..f33b48c18 100644 --- a/src/duckdb/src/main/database.cpp +++ b/src/duckdb/src/main/database.cpp @@ -27,6 +27,7 @@ #include "duckdb/transaction/transaction_manager.hpp" #include "duckdb/main/capi/extension_api.hpp" #include "duckdb/storage/compression/empty_validity.hpp" +#include "duckdb/logging/logger.hpp" #ifndef DUCKDB_NO_THREADS #include "duckdb/common/thread.hpp" @@ -38,6 +39,8 @@ DBConfig::DBConfig() { compression_functions = make_uniq(); encoding_functions = make_uniq(); encoding_functions->Initialize(*this); + arrow_extensions = make_uniq(); + arrow_extensions->Initialize(*this); cast_functions = make_uniq(*this); collation_bindings = make_uniq(); index_types = make_uniq(); @@ -71,7 +74,12 @@ DatabaseInstance::~DatabaseInstance() { object_cache.reset(); scheduler.reset(); db_manager.reset(); + + // stop the log manager, after this point Logger calls are unsafe. + log_manager.reset(); + buffer_manager.reset(); + // flush allocations and disable the background thread if (Allocator::SupportsFlush()) { Allocator::FlushAll(); @@ -285,6 +293,10 @@ void DatabaseInstance::Initialize(const char *database_path, DBConfig *user_conf } else { buffer_manager = make_uniq(*this, config.options.temporary_directory); } + + log_manager = make_shared_ptr(*this, LogConfig()); + log_manager->Initialize(); + scheduler = make_uniq(*this); object_cache = make_uniq(); connection_manager = make_uniq(); @@ -497,6 +509,7 @@ void DatabaseInstance::SetExtensionLoaded(const string &name, ExtensionInstallIn for (auto &callback : callbacks) { callback->OnExtensionLoaded(*this, name); } + Logger::Info("duckdb.Extensions.ExtensionLoaded", *this, name); } SettingLookupResult DatabaseInstance::TryGetCurrentSetting(const std::string &key, Value &result) const { @@ -522,6 +535,10 @@ const duckdb_ext_api_v1 DatabaseInstance::GetExtensionAPIV1() { return create_api_v1(); } +LogManager &DatabaseInstance::GetLogManager() const { + return *log_manager; +} + ValidChecker &ValidChecker::Get(DatabaseInstance &db) { return db.GetValidChecker(); } diff --git a/src/duckdb/src/main/database_manager.cpp b/src/duckdb/src/main/database_manager.cpp index b20394027..8b836ebfa 100644 --- a/src/duckdb/src/main/database_manager.cpp +++ b/src/duckdb/src/main/database_manager.cpp @@ -32,6 +32,9 @@ optional_ptr DatabaseManager::GetDatabase(ClientContext &conte if (StringUtil::Lower(name) == TEMP_CATALOG) { return context.client_data->temporary_objects.get(); } + if (StringUtil::Lower(name) == SYSTEM_CATALOG) { + return system; + } return reinterpret_cast(databases->GetEntry(context, name).get()); } diff --git a/src/duckdb/src/main/extension/extension_helper.cpp b/src/duckdb/src/main/extension/extension_helper.cpp index 2eb5e419b..dde0a9a5c 100644 --- a/src/duckdb/src/main/extension/extension_helper.cpp +++ b/src/duckdb/src/main/extension/extension_helper.cpp @@ -389,6 +389,8 @@ void ExtensionHelper::AutoLoadExtension(DatabaseInstance &db, const string &exte } #endif ExtensionHelper::LoadExternalExtension(db, *fs, extension_name); + Logger::Info("duckdb.Extensions.ExtensionAutoloaded", db, extension_name); + } catch (std::exception &e) { ErrorData error(e); throw AutoloadException(extension_name, error.RawMessage()); diff --git a/src/duckdb/src/main/query_result.cpp b/src/duckdb/src/main/query_result.cpp index d058e4966..fdb5b3044 100644 --- a/src/duckdb/src/main/query_result.cpp +++ b/src/duckdb/src/main/query_result.cpp @@ -61,7 +61,8 @@ QueryResult::QueryResult(QueryResultType type, StatementType statement_type, Sta } QueryResult::QueryResult(QueryResultType type, ErrorData error) - : BaseQueryResult(type, std::move(error)), client_properties("UTC", ArrowOffsetSize::REGULAR, false, false, false) { + : BaseQueryResult(type, std::move(error)), + client_properties("UTC", ArrowOffsetSize::REGULAR, false, false, false, nullptr) { } QueryResult::~QueryResult() { diff --git a/src/duckdb/src/main/settings/custom_settings.cpp b/src/duckdb/src/main/settings/custom_settings.cpp index 57e961a22..68b36362c 100644 --- a/src/duckdb/src/main/settings/custom_settings.cpp +++ b/src/duckdb/src/main/settings/custom_settings.cpp @@ -28,6 +28,8 @@ #include "duckdb/storage/buffer/buffer_pool.hpp" #include "duckdb/storage/buffer_manager.hpp" #include "duckdb/storage/storage_manager.hpp" +#include "duckdb/logging/logger.hpp" +#include "duckdb/logging/log_manager.hpp" namespace duckdb { @@ -610,6 +612,110 @@ bool EnableExternalAccessSetting::OnGlobalReset(DatabaseInstance *db, DBConfig & return true; } +//===----------------------------------------------------------------------===// +// Enable Logging +//===----------------------------------------------------------------------===// +Value EnableLogging::GetSetting(const ClientContext &context) { + return context.db->GetLogManager().GetConfig().enabled; +} +void EnableLogging::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter) { + db->GetLogManager().SetEnableLogging(parameter.GetValue()); +} + +void EnableLogging::ResetGlobal(DatabaseInstance *db, DBConfig &config) { + db->GetLogManager().SetEnableLogging(false); +} + +//===----------------------------------------------------------------------===// +// Logging Mode +//===----------------------------------------------------------------------===// +Value LoggingMode::GetSetting(const ClientContext &context) { + return EnumUtil::ToString(context.db->GetLogManager().GetConfig().mode); +} +void LoggingMode::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter) { + db->GetLogManager().SetLogMode(EnumUtil::FromString(parameter.GetValue())); +} + +void LoggingMode::ResetGlobal(DatabaseInstance *db, DBConfig &config) { + db->GetLogManager().SetLogMode(LogMode::LEVEL_ONLY); +} + +//===----------------------------------------------------------------------===// +// Logging Level +//===----------------------------------------------------------------------===// +Value LoggingLevel::GetSetting(const ClientContext &context) { + return EnumUtil::ToString(context.db->GetLogManager().GetConfig().level); +} +void LoggingLevel::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter) { + db->GetLogManager().SetLogLevel(EnumUtil::FromString(parameter.GetValue())); +} + +void LoggingLevel::ResetGlobal(DatabaseInstance *db, DBConfig &config) { + db->GetLogManager().SetLogLevel(LogConfig::DEFAULT_LOG_LEVEL); +} + +//===----------------------------------------------------------------------===// +// Logging Storage +//===----------------------------------------------------------------------===// +Value LoggingStorage::GetSetting(const ClientContext &context) { + return context.db->GetLogManager().GetConfig().storage; +} +void LoggingStorage::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter) { + db->GetLogManager().SetLogStorage(*db, parameter.GetValue()); +} + +void LoggingStorage::ResetGlobal(DatabaseInstance *db, DBConfig &config) { + db->GetLogManager().SetLogStorage(*db, LogConfig::DEFAULT_LOG_STORAGE); +} + +//===----------------------------------------------------------------------===// +// Enabled Loggers +//===----------------------------------------------------------------------===// +Value EnabledLogTypes::GetSetting(const ClientContext &context) { + vector loggers; + for (const auto &item : context.db->GetLogManager().GetConfig().enabled_log_types) { + loggers.push_back(item); + } + return StringUtil::Join(loggers, ","); +} +void EnabledLogTypes::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter) { + auto values = StringUtil::Split(parameter.GetValue(), ","); + unordered_set set; + for (const auto &value : values) { + set.insert(value); + } + db->GetLogManager().SetEnabledLogTypes(set); +} + +void EnabledLogTypes::ResetGlobal(DatabaseInstance *db, DBConfig &config) { + unordered_set set; + db->GetLogManager().SetEnabledLogTypes(set); +} + +//===----------------------------------------------------------------------===// +// Disabled Loggers +//===----------------------------------------------------------------------===// +Value DisabledLogTypes::GetSetting(const ClientContext &context) { + vector loggers; + for (const auto &item : context.db->GetLogManager().GetConfig().disabled_log_types) { + loggers.push_back(item); + } + return StringUtil::Join(loggers, ","); +} +void DisabledLogTypes::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter) { + auto values = StringUtil::Split(parameter.GetValue(), ","); + unordered_set set; + for (const auto &value : values) { + set.insert(value); + } + db->GetLogManager().SetDisabledLogTypes(set); +} + +void DisabledLogTypes::ResetGlobal(DatabaseInstance *db, DBConfig &config) { + unordered_set set; + db->GetLogManager().SetDisabledLogTypes(set); +} + //===----------------------------------------------------------------------===// // Enable Object Cache //===----------------------------------------------------------------------===// diff --git a/src/duckdb/src/optimizer/expression_rewriter.cpp b/src/duckdb/src/optimizer/expression_rewriter.cpp index a8ab28358..c8836a380 100644 --- a/src/duckdb/src/optimizer/expression_rewriter.cpp +++ b/src/duckdb/src/optimizer/expression_rewriter.cpp @@ -17,11 +17,15 @@ unique_ptr ExpressionRewriter::ApplyRules(LogicalOperator &op, const if (rule.get().root->Match(*expr, bindings)) { // the rule matches! try to apply it bool rule_made_change = false; + auto alias = expr->alias; auto result = rule.get().Apply(op, bindings, rule_made_change, is_root); if (result) { changes_made = true; // the base node changed: the rule applied changes // rerun on the new node + if (!alias.empty()) { + result->alias = std::move(alias); + } return ExpressionRewriter::ApplyRules(op, rules, std::move(result), changes_made); } else if (rule_made_change) { changes_made = true; diff --git a/src/duckdb/src/parallel/event.cpp b/src/duckdb/src/parallel/event.cpp index 0ecfddea5..a2052568c 100644 --- a/src/duckdb/src/parallel/event.cpp +++ b/src/duckdb/src/parallel/event.cpp @@ -63,6 +63,10 @@ void Event::FinishTask() { } } +ClientContext &Event::GetClientContext() { + return executor.context; +} + void Event::InsertEvent(shared_ptr replacement_event) { replacement_event->parents = std::move(parents); #ifdef DEBUG diff --git a/src/duckdb/src/parallel/thread_context.cpp b/src/duckdb/src/parallel/thread_context.cpp index 2eb15a3c3..43a10af00 100644 --- a/src/duckdb/src/parallel/thread_context.cpp +++ b/src/duckdb/src/parallel/thread_context.cpp @@ -1,10 +1,21 @@ #include "duckdb/parallel/thread_context.hpp" -#include "duckdb/execution/execution_context.hpp" #include "duckdb/main/client_context.hpp" +#include "duckdb/logging/logger.hpp" +#include "duckdb/main/database.hpp" namespace duckdb { ThreadContext::ThreadContext(ClientContext &context) : profiler(context) { + LoggingContext log_context(LogContextScope::THREAD); + log_context.client_context = reinterpret_cast(&context); + log_context.thread = TaskScheduler::GetEstimatedCPUId(); + if (context.transaction.HasActiveTransaction()) { + log_context.transaction_id = context.transaction.GetActiveQuery(); + } + logger = context.db->GetLogManager().CreateLogger(log_context, true); +} + +ThreadContext::~ThreadContext() { } } // namespace duckdb diff --git a/src/duckdb/src/transaction/meta_transaction.cpp b/src/duckdb/src/transaction/meta_transaction.cpp index 4c4baceca..446a7e6a3 100644 --- a/src/duckdb/src/transaction/meta_transaction.cpp +++ b/src/duckdb/src/transaction/meta_transaction.cpp @@ -1,8 +1,9 @@ #include "duckdb/transaction/meta_transaction.hpp" -#include "duckdb/main/client_context.hpp" + +#include "duckdb/common/exception/transaction_exception.hpp" #include "duckdb/main/attached_database.hpp" +#include "duckdb/main/client_context.hpp" #include "duckdb/transaction/transaction_manager.hpp" -#include "duckdb/common/exception/transaction_exception.hpp" namespace duckdb { diff --git a/src/duckdb/ub_src_common_arrow.cpp b/src/duckdb/ub_src_common_arrow.cpp index 9c8e239da..fc223df96 100644 --- a/src/duckdb/ub_src_common_arrow.cpp +++ b/src/duckdb/ub_src_common_arrow.cpp @@ -2,12 +2,14 @@ #include "src/common/arrow/arrow_converter.cpp" -#include "src/common/arrow/arrow_util.cpp" +#include "src/common/arrow/arrow_type_extension.cpp" #include "src/common/arrow/arrow_merge_event.cpp" #include "src/common/arrow/arrow_query_result.cpp" +#include "src/common/arrow/arrow_util.cpp" + #include "src/common/arrow/arrow_wrapper.cpp" #include "src/common/arrow/physical_arrow_collector.cpp" diff --git a/src/duckdb/ub_src_function_scalar_system.cpp b/src/duckdb/ub_src_function_scalar_system.cpp index 58c4a1fda..98eac32ca 100644 --- a/src/duckdb/ub_src_function_scalar_system.cpp +++ b/src/duckdb/ub_src_function_scalar_system.cpp @@ -1,2 +1,4 @@ #include "src/function/scalar/system/aggregate_export.cpp" +#include "src/function/scalar/system/write_log.cpp" + diff --git a/src/duckdb/ub_src_function_table_system.cpp b/src/duckdb/ub_src_function_table_system.cpp index 4ab6fdaf7..95fcbe8fa 100644 --- a/src/duckdb/ub_src_function_table_system.cpp +++ b/src/duckdb/ub_src_function_table_system.cpp @@ -12,6 +12,10 @@ #include "src/function/table/system/duckdb_keywords.cpp" +#include "src/function/table/system/duckdb_log.cpp" + +#include "src/function/table/system/duckdb_log_contexts.cpp" + #include "src/function/table/system/duckdb_indexes.cpp" #include "src/function/table/system/duckdb_memory.cpp" diff --git a/src/duckdb/ub_src_logging.cpp b/src/duckdb/ub_src_logging.cpp new file mode 100644 index 000000000..5800b81b4 --- /dev/null +++ b/src/duckdb/ub_src_logging.cpp @@ -0,0 +1,8 @@ +#include "src/logging/logger.cpp" + +#include "src/logging/log_manager.cpp" + +#include "src/logging/log_storage.cpp" + +#include "src/logging/logging.cpp" + From c474827ba7da50011ef367d93074981737252a92 Mon Sep 17 00:00:00 2001 From: DuckDB Labs GitHub Bot Date: Tue, 14 Jan 2025 00:32:36 +0000 Subject: [PATCH 12/16] Update vendored DuckDB sources to db6ceda1 --- src/duckdb/src/common/types/varint.cpp | 66 ++++++++++++++----- .../scanner/column_count_scanner.cpp | 7 +- .../function/table/version/pragma_version.cpp | 6 +- .../include/duckdb/common/types/varint.hpp | 11 ++++ .../storage/compression/roaring/roaring.hpp | 4 +- src/duckdb/src/logging/log_manager.cpp | 2 + .../compression/dictionary/decompression.cpp | 11 +--- .../compression/dictionary_compression.cpp | 4 +- .../storage/compression/roaring/analyze.cpp | 12 ++-- .../table/column_data_checkpointer.cpp | 12 +++- 10 files changed, 92 insertions(+), 43 deletions(-) diff --git a/src/duckdb/src/common/types/varint.cpp b/src/duckdb/src/common/types/varint.cpp index b92ded113..6c0c1019f 100644 --- a/src/duckdb/src/common/types/varint.cpp +++ b/src/duckdb/src/common/types/varint.cpp @@ -1,5 +1,7 @@ #include "duckdb/common/types/varint.hpp" #include "duckdb/common/exception/conversion_exception.hpp" +#include "duckdb/common/numeric_utils.hpp" +#include "duckdb/common/typedefs.hpp" #include namespace duckdb { @@ -34,7 +36,7 @@ void Varint::Verify(const string_t &input) { // No bytes between 4 and end can be 0, unless total size == 4 if (varint_bytes > 4) { if (is_negative) { - if (~varint_ptr[3] == 0) { + if (static_cast(~varint_ptr[3]) == 0) { throw InternalException("Invalid top data bytes set to 0 for VARINT values"); } } else { @@ -159,10 +161,13 @@ void Varint::GetByteArray(vector &byte_array, bool &is_negative, const // Determine if the number is negative is_negative = (blob_ptr[0] & 0x80) == 0; - for (idx_t i = 3; i < blob.GetSize(); i++) { - if (is_negative) { + byte_array.reserve(blob.GetSize() - 3); + if (is_negative) { + for (idx_t i = 3; i < blob.GetSize(); i++) { byte_array.push_back(static_cast(~blob_ptr[i])); - } else { + } + } else { + for (idx_t i = 3; i < blob.GetSize(); i++) { byte_array.push_back(static_cast(blob_ptr[i])); } } @@ -184,28 +189,53 @@ string Varint::FromByteArray(uint8_t *data, idx_t size, bool is_negative) { return result; } +// Following CPython and Knuth (TAOCP, Volume 2 (3rd edn), section 4.4, Method 1b). string Varint::VarIntToVarchar(const string_t &blob) { string decimal_string; vector byte_array; bool is_negative; GetByteArray(byte_array, is_negative, blob); - while (!byte_array.empty()) { - string quotient; - uint8_t remainder = 0; - for (uint8_t byte : byte_array) { - int new_value = remainder * 256 + byte; - quotient += DigitToChar(new_value / 10); - remainder = static_cast(new_value % 10); + vector digits; + // Rounding byte_array to digit_bytes multiple size, so that we can process every digit_bytes bytes + // at a time without if check in the for loop + idx_t padding_size = (-byte_array.size()) & (DIGIT_BYTES - 1); + byte_array.insert(byte_array.begin(), padding_size, 0); + for (idx_t i = 0; i < byte_array.size(); i += DIGIT_BYTES) { + digit_t hi = 0; + for (idx_t j = 0; j < DIGIT_BYTES; j++) { + hi |= UnsafeNumericCast(byte_array[i + j]) << (8 * (DIGIT_BYTES - j - 1)); } - decimal_string += DigitToChar(remainder); - // Remove leading zeros from the quotient - byte_array.clear(); - for (char digit : quotient) { - if (digit != '0' || !byte_array.empty()) { - byte_array.push_back(static_cast(CharToDigit(digit))); - } + + for (idx_t j = 0; j < digits.size(); j++) { + twodigit_t tmp = UnsafeNumericCast(digits[j]) << DIGIT_BITS | hi; + hi = static_cast(tmp / UnsafeNumericCast(DECIMAL_BASE)); + digits[j] = static_cast(tmp - UnsafeNumericCast(DECIMAL_BASE * hi)); + } + + while (hi) { + digits.push_back(hi % DECIMAL_BASE); + hi /= DECIMAL_BASE; + } + } + + if (digits.empty()) { + digits.push_back(0); + } + + for (idx_t i = 0; i < digits.size() - 1; i++) { + auto remain = digits[i]; + for (idx_t j = 0; j < DECIMAL_SHIFT; j++) { + decimal_string += DigitToChar(static_cast(remain % 10)); + remain /= 10; } } + + auto remain = digits.back(); + do { + decimal_string += DigitToChar(static_cast(remain % 10)); + remain /= 10; + } while (remain != 0); + if (is_negative) { decimal_string += '-'; } diff --git a/src/duckdb/src/execution/operator/csv_scanner/scanner/column_count_scanner.cpp b/src/duckdb/src/execution/operator/csv_scanner/scanner/column_count_scanner.cpp index 7c4b7bb9c..906ace12b 100644 --- a/src/duckdb/src/execution/operator/csv_scanner/scanner/column_count_scanner.cpp +++ b/src/duckdb/src/execution/operator/csv_scanner/scanner/column_count_scanner.cpp @@ -141,12 +141,17 @@ void ColumnCountScanner::FinalizeChunkProcess() { cur_buffer_handle = buffer_manager->GetBuffer(++iterator.pos.buffer_idx); if (!cur_buffer_handle) { buffer_handle_ptr = nullptr; + if (states.IsQuotedCurrent() && !states.IsUnquoted()) { + // We are finishing our file on a quoted value that is never unquoted, straight to jail. + result.error = true; + return; + } if (states.EmptyLine() || states.NewRow() || states.IsCurrentNewRow() || states.IsNotSet()) { return; } // This means we reached the end of the file, we must add a last line if there is any to be added if (result.comment) { - // If it's a comment we add the last line via unsetcomment + // If it's a comment we add the last line via unset comment result.UnsetComment(result, NumericLimits::Maximum()); } else { // OW, we do a regular AddRow diff --git a/src/duckdb/src/function/table/version/pragma_version.cpp b/src/duckdb/src/function/table/version/pragma_version.cpp index 48497da5d..0b422410e 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 "4-dev4483" +#define DUCKDB_PATCH_VERSION "4-dev4516" #endif #ifndef DUCKDB_MINOR_VERSION #define DUCKDB_MINOR_VERSION 1 @@ -8,10 +8,10 @@ #define DUCKDB_MAJOR_VERSION 1 #endif #ifndef DUCKDB_VERSION -#define DUCKDB_VERSION "v1.1.4-dev4483" +#define DUCKDB_VERSION "v1.1.4-dev4516" #endif #ifndef DUCKDB_SOURCE_ID -#define DUCKDB_SOURCE_ID "1c6ea28bdc" +#define DUCKDB_SOURCE_ID "2e533ec9df" #endif #include "duckdb/function/table/system_functions.hpp" #include "duckdb/main/database.hpp" diff --git a/src/duckdb/src/include/duckdb/common/types/varint.hpp b/src/duckdb/src/include/duckdb/common/types/varint.hpp index 7a4b5b485..e0b99cbab 100644 --- a/src/duckdb/src/include/duckdb/common/types/varint.hpp +++ b/src/duckdb/src/include/duckdb/common/types/varint.hpp @@ -16,11 +16,22 @@ #include "duckdb/function/cast/default_casts.hpp" namespace duckdb { +using digit_t = uint32_t; +using twodigit_t = uint64_t; + //! The Varint class is a static class that holds helper functions for the Varint type. class Varint { public: //! Header size of a Varint is always 3 bytes. DUCKDB_API static constexpr uint8_t VARINT_HEADER_SIZE = 3; + //! Max(e such that 10**e fits in a digit_t) + DUCKDB_API static constexpr uint8_t DECIMAL_SHIFT = 9; + //! 10 ** DECIMAL_SHIFT + DUCKDB_API static constexpr digit_t DECIMAL_BASE = 1000000000; + //! Bytes of a digit_t + DUCKDB_API static constexpr uint8_t DIGIT_BYTES = sizeof(digit_t); + //! Bits of a digit_t + DUCKDB_API static constexpr uint8_t DIGIT_BITS = DIGIT_BYTES * 8; //! Verifies if a Varint is valid. i.e., if it has 3 header bytes. The header correctly represents the number of //! data bytes, and the data bytes has no leading zero bytes. DUCKDB_API static void Verify(const string_t &input); diff --git a/src/duckdb/src/include/duckdb/storage/compression/roaring/roaring.hpp b/src/duckdb/src/include/duckdb/storage/compression/roaring/roaring.hpp index 7a2d1ddaa..c20613744 100644 --- a/src/duckdb/src/include/duckdb/storage/compression/roaring/roaring.hpp +++ b/src/duckdb/src/include/duckdb/storage/compression/roaring/roaring.hpp @@ -244,7 +244,9 @@ struct RoaringAnalyzeState : public AnalyzeState { //! Flushed analyze data //! The space used by the current segment - idx_t space_used = 0; + idx_t data_size = 0; + idx_t metadata_size = 0; + //! The total amount of segments to write idx_t segment_count = 0; //! The amount of values in the current segment; diff --git a/src/duckdb/src/logging/log_manager.cpp b/src/duckdb/src/logging/log_manager.cpp index 2a2aaae86..c937b3fda 100644 --- a/src/duckdb/src/logging/log_manager.cpp +++ b/src/duckdb/src/logging/log_manager.cpp @@ -143,6 +143,8 @@ void LogManager::SetLogStorage(DatabaseInstance &db, const string &storage_name) throw NotImplementedException("File log storage is not yet implemented"); } else if (registered_log_storages.find(storage_name_to_lower) != registered_log_storages.end()) { log_storage = registered_log_storages[storage_name_to_lower]; + } else { + throw InvalidInputException("Log storage '%s' is not yet registered", storage_name); } config.storage = storage_name_to_lower; } diff --git a/src/duckdb/src/storage/compression/dictionary/decompression.cpp b/src/duckdb/src/storage/compression/dictionary/decompression.cpp index 4063e9224..a81c0e122 100644 --- a/src/duckdb/src/storage/compression/dictionary/decompression.cpp +++ b/src/duckdb/src/storage/compression/dictionary/decompression.cpp @@ -43,18 +43,15 @@ void CompressedStringScanState::Initialize(ColumnSegment &segment, bool initiali block_size = segment.GetBlockManager().GetBlockSize(); dict = DictionaryCompression::GetDictionary(segment, *handle); + dictionary = make_buffer(segment.type, index_buffer_count); + dictionary_size = index_buffer_count; if (!initialize_dictionary) { // Used by fetch, as fetch will never produce a DictionaryVector return; } - dictionary = make_buffer(segment.type, index_buffer_count); - dictionary_size = index_buffer_count; auto dict_child_data = FlatVector::GetData(*(dictionary)); - auto &validity = FlatVector::Validity(*dictionary); - D_ASSERT(index_buffer_count >= 1); - validity.SetInvalid(0); for (uint32_t i = 0; i < index_buffer_count; i++) { // NOTE: the passing of dict_child_vector, will not be used, its for big strings uint16_t str_len = GetStringLength(i); @@ -64,7 +61,6 @@ void CompressedStringScanState::Initialize(ColumnSegment &segment, bool initiali void CompressedStringScanState::ScanToFlatVector(Vector &result, idx_t result_offset, idx_t start, idx_t scan_count) { auto result_data = FlatVector::GetData(result); - auto &validity = FlatVector::Validity(result); // Handling non-bitpacking-group-aligned start values; idx_t start_offset = start % BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE; @@ -86,9 +82,6 @@ void CompressedStringScanState::ScanToFlatVector(Vector &result, idx_t result_of for (idx_t i = 0; i < scan_count; i++) { // Lookup dict offset in index buffer auto string_number = sel_vec->get_index(i + start_offset); - if (string_number == 0) { - validity.SetInvalid(result_offset + i); - } auto dict_offset = index_buffer_ptr[string_number]; auto str_len = GetStringLength(UnsafeNumericCast(string_number)); result_data[result_offset + i] = FetchStringFromDict(UnsafeNumericCast(dict_offset), str_len); diff --git a/src/duckdb/src/storage/compression/dictionary_compression.cpp b/src/duckdb/src/storage/compression/dictionary_compression.cpp index 78915a374..6f6b4beed 100644 --- a/src/duckdb/src/storage/compression/dictionary_compression.cpp +++ b/src/duckdb/src/storage/compression/dictionary_compression.cpp @@ -157,7 +157,7 @@ void DictionaryCompressionStorage::StringFetchRow(ColumnSegment &segment, Column // Get Function //===--------------------------------------------------------------------===// CompressionFunction DictionaryCompressionFun::GetFunction(PhysicalType data_type) { - auto res = CompressionFunction( + return CompressionFunction( CompressionType::COMPRESSION_DICTIONARY, data_type, DictionaryCompressionStorage ::StringInitAnalyze, DictionaryCompressionStorage::StringAnalyze, DictionaryCompressionStorage::StringFinalAnalyze, DictionaryCompressionStorage::InitCompression, DictionaryCompressionStorage::Compress, @@ -165,8 +165,6 @@ CompressionFunction DictionaryCompressionFun::GetFunction(PhysicalType data_type DictionaryCompressionStorage::StringScan, DictionaryCompressionStorage::StringScanPartial, DictionaryCompressionStorage::StringFetchRow, UncompressedFunctions::EmptySkip, UncompressedStringStorage::StringInitSegment); - res.validity = CompressionValidity::NO_VALIDITY_REQUIRED; - return res; } bool DictionaryCompressionFun::TypeIsSupported(const PhysicalType physical_type) { diff --git a/src/duckdb/src/storage/compression/roaring/analyze.cpp b/src/duckdb/src/storage/compression/roaring/analyze.cpp index f5a49eb29..76cfa849e 100644 --- a/src/duckdb/src/storage/compression/roaring/analyze.cpp +++ b/src/duckdb/src/storage/compression/roaring/analyze.cpp @@ -108,6 +108,7 @@ void RoaringAnalyzeState::Flush(RoaringAnalyzeState &state) { } bool RoaringAnalyzeState::HasEnoughSpaceInSegment(idx_t required_space) { + auto space_used = data_size + metadata_size; D_ASSERT(space_used <= info.GetBlockSize()); idx_t remaining_space = info.GetBlockSize() - space_used; if (required_space > remaining_space) { @@ -117,13 +118,15 @@ bool RoaringAnalyzeState::HasEnoughSpaceInSegment(idx_t required_space) { } void RoaringAnalyzeState::FlushSegment() { + auto space_used = data_size + metadata_size; if (!current_count) { D_ASSERT(!space_used); return; } metadata_collection.FlushSegment(); total_size += space_used; - space_used = 0; + data_size = 0; + metadata_size = 0; current_count = 0; segment_count++; } @@ -146,15 +149,14 @@ void RoaringAnalyzeState::FlushContainer() { arrays_count++; } - idx_t required_space = metadata_collection.GetMetadataSize(runs_count + arrays_count, runs_count, arrays_count); + metadata_size = metadata_collection.GetMetadataSize(runs_count + arrays_count, runs_count, arrays_count); - required_space += metadata.GetDataSizeInBytes(count); - if (!HasEnoughSpaceInSegment(required_space)) { + data_size += metadata.GetDataSizeInBytes(count); + if (!HasEnoughSpaceInSegment(metadata_size + data_size)) { FlushSegment(); } container_metadata.push_back(metadata); metadata_collection.AddMetadata(metadata); - space_used += required_space; current_count += count; // Reset the container analyze state diff --git a/src/duckdb/src/storage/table/column_data_checkpointer.cpp b/src/duckdb/src/storage/table/column_data_checkpointer.cpp index ae92a6972..305b1ea86 100644 --- a/src/duckdb/src/storage/table/column_data_checkpointer.cpp +++ b/src/duckdb/src/storage/table/column_data_checkpointer.cpp @@ -5,6 +5,7 @@ #include "duckdb/storage/data_table.hpp" #include "duckdb/parser/column_definition.hpp" #include "duckdb/storage/table/scan_state.hpp" +#include "duckdb/main/database.hpp" namespace duckdb { @@ -240,14 +241,19 @@ vector ColumnDataCheckpointer::DetectBestCompressionMet } } + auto &checkpoint_state = checkpoint_states[i]; + auto &col_data = checkpoint_state.get().column_data; if (!chosen_state) { - auto &checkpoint_state = checkpoint_states[i]; - auto &col_data = checkpoint_state.get().column_data; throw FatalException("No suitable compression/storage method found to store column of type %s", col_data.type.ToString()); } D_ASSERT(compression_idx != DConstants::INVALID_INDEX); - result[i] = CheckpointAnalyzeResult(std::move(chosen_state), *functions[compression_idx]); + + auto &best_function = *functions[compression_idx]; + Logger::Info(db, "FinalAnalyze(%s) result for %s.%s.%d(%s): %d", EnumUtil::ToString(best_function.type), + col_data.info.GetSchemaName(), col_data.info.GetTableName(), col_data.column_index, + col_data.type.ToString(), best_score); + result[i] = CheckpointAnalyzeResult(std::move(chosen_state), best_function); } return result; } From 4d88718b6dba7c9160633cf81071073b0bd26096 Mon Sep 17 00:00:00 2001 From: DuckDB Labs GitHub Bot Date: Wed, 15 Jan 2025 00:33:20 +0000 Subject: [PATCH 13/16] Update vendored DuckDB sources to c474827b --- .../extension/json/buffered_json_reader.cpp | 2 +- .../json/json_functions/read_json_objects.cpp | 4 +- src/duckdb/src/common/enum_util.cpp | 14 +- src/duckdb/src/common/enums/metric_type.cpp | 6 + .../src/common/enums/optimizer_type.cpp | 1 + src/duckdb/src/common/local_file_system.cpp | 17 +- .../csv_scanner/sniffer/header_detection.cpp | 7 + .../csv_scanner/sniffer/type_detection.cpp | 1 + .../src/function/scalar/strftime_format.cpp | 10 + src/duckdb/src/function/table/table_scan.cpp | 2 +- .../function/table/version/pragma_version.cpp | 6 +- .../duckdb/common/enums/metric_type.hpp | 1 + .../duckdb/common/enums/optimizer_type.hpp | 3 +- .../src/include/duckdb/common/helper.hpp | 6 + .../csv_scanner/sniffer/csv_sniffer.hpp | 2 + .../function/scalar/strftime_format.hpp | 1 + .../duckdb/function/table/table_scan.hpp | 7 + .../src/include/duckdb/main/client_config.hpp | 3 + src/duckdb/src/include/duckdb/main/config.hpp | 3 + .../src/include/duckdb/main/database.hpp | 2 - .../include/duckdb/main/db_instance_cache.hpp | 1 + .../include/duckdb/main/extension_entries.hpp | 1 + .../src/include/duckdb/main/settings.hpp | 11 + .../duckdb/optimizer/late_materialization.hpp | 45 ++ .../optimizer/remove_unused_columns.hpp | 48 +- .../duckdb/planner/operator/logical_get.hpp | 2 +- .../storage/compression/roaring/roaring.hpp | 6 +- src/duckdb/src/main/config.cpp | 1 + src/duckdb/src/main/database.cpp | 11 +- src/duckdb/src/main/db_instance_cache.cpp | 21 +- .../main/settings/autogenerated_settings.cpp | 17 + .../src/optimizer/late_materialization.cpp | 414 ++++++++++++++++++ src/duckdb/src/optimizer/optimizer.cpp | 7 + .../src/optimizer/remove_unused_columns.cpp | 23 +- .../storage/compression/roaring/compress.cpp | 17 +- .../src/storage/compression/roaring/scan.cpp | 6 + src/duckdb/src/storage/table/row_group.cpp | 16 +- src/duckdb/ub_src_optimizer.cpp | 2 + 38 files changed, 664 insertions(+), 83 deletions(-) create mode 100644 src/duckdb/src/include/duckdb/optimizer/late_materialization.hpp create mode 100644 src/duckdb/src/optimizer/late_materialization.cpp diff --git a/src/duckdb/extension/json/buffered_json_reader.cpp b/src/duckdb/extension/json/buffered_json_reader.cpp index f99fe0321..68a830c7f 100644 --- a/src/duckdb/extension/json/buffered_json_reader.cpp +++ b/src/duckdb/extension/json/buffered_json_reader.cpp @@ -35,7 +35,7 @@ void JSONFileHandle::Reset() { requested_reads = 0; actual_reads = 0; last_read_requested = false; - if (IsOpen() && CanSeek()) { + if (IsOpen() && !file_handle->IsPipe()) { file_handle->Reset(); } } diff --git a/src/duckdb/extension/json/json_functions/read_json_objects.cpp b/src/duckdb/extension/json/json_functions/read_json_objects.cpp index a0e6e6b8f..c58b85fd7 100644 --- a/src/duckdb/extension/json/json_functions/read_json_objects.cpp +++ b/src/duckdb/extension/json/json_functions/read_json_objects.cpp @@ -64,8 +64,8 @@ TableFunction GetReadJSONObjectsTableFunction(bool list_parameter, shared_ptr(JSONScanType::READ_JSON_OBJECTS, JSONFormat::ARRAY, JSONRecordType::RECORDS); + auto function_info = make_shared_ptr(JSONScanType::READ_JSON_OBJECTS, JSONFormat::AUTO_DETECT, + JSONRecordType::RECORDS); function_set.AddFunction(GetReadJSONObjectsTableFunction(false, function_info)); function_set.AddFunction(GetReadJSONObjectsTableFunction(true, function_info)); return function_set; diff --git a/src/duckdb/src/common/enum_util.cpp b/src/duckdb/src/common/enum_util.cpp index 88660f982..c3a99f657 100644 --- a/src/duckdb/src/common/enum_util.cpp +++ b/src/duckdb/src/common/enum_util.cpp @@ -2399,19 +2399,20 @@ const StringUtil::EnumStringLiteral *GetMetricsTypeValues() { { static_cast(MetricsType::OPTIMIZER_JOIN_FILTER_PUSHDOWN), "OPTIMIZER_JOIN_FILTER_PUSHDOWN" }, { static_cast(MetricsType::OPTIMIZER_EXTENSION), "OPTIMIZER_EXTENSION" }, { static_cast(MetricsType::OPTIMIZER_MATERIALIZED_CTE), "OPTIMIZER_MATERIALIZED_CTE" }, - { static_cast(MetricsType::OPTIMIZER_SUM_REWRITER), "OPTIMIZER_SUM_REWRITER" } + { static_cast(MetricsType::OPTIMIZER_SUM_REWRITER), "OPTIMIZER_SUM_REWRITER" }, + { static_cast(MetricsType::OPTIMIZER_LATE_MATERIALIZATION), "OPTIMIZER_LATE_MATERIALIZATION" } }; return values; } template<> const char* EnumUtil::ToChars(MetricsType value) { - return StringUtil::EnumToString(GetMetricsTypeValues(), 48, "MetricsType", static_cast(value)); + return StringUtil::EnumToString(GetMetricsTypeValues(), 49, "MetricsType", static_cast(value)); } template<> MetricsType EnumUtil::FromString(const char *value) { - return static_cast(StringUtil::StringToEnum(GetMetricsTypeValues(), 48, "MetricsType", value)); + return static_cast(StringUtil::StringToEnum(GetMetricsTypeValues(), 49, "MetricsType", value)); } const StringUtil::EnumStringLiteral *GetNTypeValues() { @@ -2584,19 +2585,20 @@ const StringUtil::EnumStringLiteral *GetOptimizerTypeValues() { { static_cast(OptimizerType::JOIN_FILTER_PUSHDOWN), "JOIN_FILTER_PUSHDOWN" }, { static_cast(OptimizerType::EXTENSION), "EXTENSION" }, { static_cast(OptimizerType::MATERIALIZED_CTE), "MATERIALIZED_CTE" }, - { static_cast(OptimizerType::SUM_REWRITER), "SUM_REWRITER" } + { static_cast(OptimizerType::SUM_REWRITER), "SUM_REWRITER" }, + { static_cast(OptimizerType::LATE_MATERIALIZATION), "LATE_MATERIALIZATION" } }; return values; } template<> const char* EnumUtil::ToChars(OptimizerType value) { - return StringUtil::EnumToString(GetOptimizerTypeValues(), 27, "OptimizerType", static_cast(value)); + return StringUtil::EnumToString(GetOptimizerTypeValues(), 28, "OptimizerType", static_cast(value)); } template<> OptimizerType EnumUtil::FromString(const char *value) { - return static_cast(StringUtil::StringToEnum(GetOptimizerTypeValues(), 27, "OptimizerType", value)); + return static_cast(StringUtil::StringToEnum(GetOptimizerTypeValues(), 28, "OptimizerType", value)); } const StringUtil::EnumStringLiteral *GetOrderByNullTypeValues() { diff --git a/src/duckdb/src/common/enums/metric_type.cpp b/src/duckdb/src/common/enums/metric_type.cpp index 94a75cc1e..d97579c23 100644 --- a/src/duckdb/src/common/enums/metric_type.cpp +++ b/src/duckdb/src/common/enums/metric_type.cpp @@ -39,6 +39,7 @@ profiler_settings_t MetricsUtils::GetOptimizerMetrics() { MetricsType::OPTIMIZER_EXTENSION, MetricsType::OPTIMIZER_MATERIALIZED_CTE, MetricsType::OPTIMIZER_SUM_REWRITER, + MetricsType::OPTIMIZER_LATE_MATERIALIZATION, }; } @@ -109,6 +110,8 @@ MetricsType MetricsUtils::GetOptimizerMetricByType(OptimizerType type) { return MetricsType::OPTIMIZER_MATERIALIZED_CTE; case OptimizerType::SUM_REWRITER: return MetricsType::OPTIMIZER_SUM_REWRITER; + case OptimizerType::LATE_MATERIALIZATION: + return MetricsType::OPTIMIZER_LATE_MATERIALIZATION; default: throw InternalException("OptimizerType %s cannot be converted to a MetricsType", EnumUtil::ToString(type)); }; @@ -168,6 +171,8 @@ OptimizerType MetricsUtils::GetOptimizerTypeByMetric(MetricsType type) { return OptimizerType::MATERIALIZED_CTE; case MetricsType::OPTIMIZER_SUM_REWRITER: return OptimizerType::SUM_REWRITER; + case MetricsType::OPTIMIZER_LATE_MATERIALIZATION: + return OptimizerType::LATE_MATERIALIZATION; default: return OptimizerType::INVALID; }; @@ -201,6 +206,7 @@ bool MetricsUtils::IsOptimizerMetric(MetricsType type) { case MetricsType::OPTIMIZER_EXTENSION: case MetricsType::OPTIMIZER_MATERIALIZED_CTE: case MetricsType::OPTIMIZER_SUM_REWRITER: + case MetricsType::OPTIMIZER_LATE_MATERIALIZATION: return true; default: return false; diff --git a/src/duckdb/src/common/enums/optimizer_type.cpp b/src/duckdb/src/common/enums/optimizer_type.cpp index f2555dc58..f4d02d68a 100644 --- a/src/duckdb/src/common/enums/optimizer_type.cpp +++ b/src/duckdb/src/common/enums/optimizer_type.cpp @@ -38,6 +38,7 @@ static const DefaultOptimizerType internal_optimizer_types[] = { {"extension", OptimizerType::EXTENSION}, {"materialized_cte", OptimizerType::MATERIALIZED_CTE}, {"sum_rewriter", OptimizerType::SUM_REWRITER}, + {"late_materialization", OptimizerType::LATE_MATERIALIZATION}, {nullptr, OptimizerType::INVALID}}; string OptimizerTypeToString(OptimizerType type) { diff --git a/src/duckdb/src/common/local_file_system.cpp b/src/duckdb/src/common/local_file_system.cpp index 7136dc715..89990c767 100644 --- a/src/duckdb/src/common/local_file_system.cpp +++ b/src/duckdb/src/common/local_file_system.cpp @@ -853,16 +853,27 @@ unique_ptr LocalFileSystem::OpenFile(const string &path_p, FileOpenF bool open_write = flags.OpenForWriting(); if (open_read && open_write) { desired_access = GENERIC_READ | GENERIC_WRITE; - share_mode = 0; } else if (open_read) { desired_access = GENERIC_READ; - share_mode = FILE_SHARE_READ; } else if (open_write) { desired_access = GENERIC_WRITE; - share_mode = 0; } else { throw InternalException("READ, WRITE or both should be specified when opening a file"); } + switch (flags.Lock()) { + case FileLockType::NO_LOCK: + share_mode = FILE_SHARE_READ | FILE_SHARE_WRITE; + break; + case FileLockType::READ_LOCK: + share_mode = FILE_SHARE_READ; + break; + case FileLockType::WRITE_LOCK: + share_mode = 0; + break; + default: + throw InternalException("Unknown FileLockType"); + } + if (open_write) { if (flags.CreateFileIfNotExists()) { creation_disposition = OPEN_ALWAYS; diff --git a/src/duckdb/src/execution/operator/csv_scanner/sniffer/header_detection.cpp b/src/duckdb/src/execution/operator/csv_scanner/sniffer/header_detection.cpp index 424468c55..6581018c7 100644 --- a/src/duckdb/src/execution/operator/csv_scanner/sniffer/header_detection.cpp +++ b/src/duckdb/src/execution/operator/csv_scanner/sniffer/header_detection.cpp @@ -335,6 +335,13 @@ void CSVSniffer::DetectHeader() { auto &sniffer_state_machine = best_candidate->GetStateMachine(); names = DetectHeaderInternal(buffer_manager->context, best_header_row, sniffer_state_machine, set_columns, best_sql_types_candidates_per_column_idx, options, *error_handler); + if (single_row_file && sniffer_state_machine.dialect_options.header.GetValue()) { + // This file only contains a header, lets default to the lowest type of all. + detected_types.clear(); + for (idx_t i = 0; i < names.size(); i++) { + detected_types.push_back(LogicalType::BOOLEAN); + } + } for (idx_t i = max_columns_found; i < names.size(); i++) { detected_types.push_back(LogicalType::VARCHAR); } diff --git a/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_detection.cpp b/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_detection.cpp index d6b2b1a6b..e58b66433 100644 --- a/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_detection.cpp +++ b/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_detection.cpp @@ -467,6 +467,7 @@ void CSVSniffer::DetectTypes() { best_format_candidates[format_candidate.first] = format_candidate.second.format; } if (chunk_size > 0) { + single_row_file = chunk_size == 1; for (idx_t col_idx = 0; col_idx < data_chunk.ColumnCount(); col_idx++) { auto &cur_vector = data_chunk.data[col_idx]; auto vector_data = FlatVector::GetData(cur_vector); diff --git a/src/duckdb/src/function/scalar/strftime_format.cpp b/src/duckdb/src/function/scalar/strftime_format.cpp index 8ab46ace7..58ccd9959 100644 --- a/src/duckdb/src/function/scalar/strftime_format.cpp +++ b/src/duckdb/src/function/scalar/strftime_format.cpp @@ -1412,6 +1412,16 @@ StrpTimeFormat::ParseResult StrpTimeFormat::Parse(const string &format_string, c return result; } +bool StrpTimeFormat::TryParse(const string &format_string, const string &text, ParseResult &result) { + StrpTimeFormat format; + format.format_specifier = format_string; + string error = StrTimeFormat::ParseFormatSpecifier(format_string, format); + if (!error.empty()) { + throw InvalidInputException("Failed to parse format specifier %s: %s", format_string, error); + } + return format.Parse(text, result); +} + bool StrTimeFormat::Empty() const { return format_specifier.empty(); } diff --git a/src/duckdb/src/function/table/table_scan.cpp b/src/duckdb/src/function/table/table_scan.cpp index dafe070d1..1b67d3b9b 100644 --- a/src/duckdb/src/function/table/table_scan.cpp +++ b/src/duckdb/src/function/table/table_scan.cpp @@ -105,7 +105,7 @@ class DuckIndexScanState : public TableScanGlobalState { //! The batch index of the next Sink. //! Also determines the offset of the next chunk. I.e., offset = next_batch_index * STANDARD_VECTOR_SIZE. - idx_t next_batch_index; + atomic next_batch_index; //! The total scanned row IDs. unsafe_vector row_ids; //! The column IDs of the to-be-scanned columns. diff --git a/src/duckdb/src/function/table/version/pragma_version.cpp b/src/duckdb/src/function/table/version/pragma_version.cpp index 0b422410e..de1ba7272 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 "4-dev4516" +#define DUCKDB_PATCH_VERSION "4-dev4570" #endif #ifndef DUCKDB_MINOR_VERSION #define DUCKDB_MINOR_VERSION 1 @@ -8,10 +8,10 @@ #define DUCKDB_MAJOR_VERSION 1 #endif #ifndef DUCKDB_VERSION -#define DUCKDB_VERSION "v1.1.4-dev4516" +#define DUCKDB_VERSION "v1.1.4-dev4570" #endif #ifndef DUCKDB_SOURCE_ID -#define DUCKDB_SOURCE_ID "2e533ec9df" +#define DUCKDB_SOURCE_ID "d1740d6cf7" #endif #include "duckdb/function/table/system_functions.hpp" #include "duckdb/main/database.hpp" diff --git a/src/duckdb/src/include/duckdb/common/enums/metric_type.hpp b/src/duckdb/src/include/duckdb/common/enums/metric_type.hpp index c133faada..14389bf4a 100644 --- a/src/duckdb/src/include/duckdb/common/enums/metric_type.hpp +++ b/src/duckdb/src/include/duckdb/common/enums/metric_type.hpp @@ -68,6 +68,7 @@ enum class MetricsType : uint8_t { OPTIMIZER_EXTENSION, OPTIMIZER_MATERIALIZED_CTE, OPTIMIZER_SUM_REWRITER, + OPTIMIZER_LATE_MATERIALIZATION, }; struct MetricsTypeHashFunction { diff --git a/src/duckdb/src/include/duckdb/common/enums/optimizer_type.hpp b/src/duckdb/src/include/duckdb/common/enums/optimizer_type.hpp index cfb7acb6a..adabacec2 100644 --- a/src/duckdb/src/include/duckdb/common/enums/optimizer_type.hpp +++ b/src/duckdb/src/include/duckdb/common/enums/optimizer_type.hpp @@ -40,7 +40,8 @@ enum class OptimizerType : uint32_t { JOIN_FILTER_PUSHDOWN, EXTENSION, MATERIALIZED_CTE, - SUM_REWRITER + SUM_REWRITER, + LATE_MATERIALIZATION }; string OptimizerTypeToString(OptimizerType type); diff --git a/src/duckdb/src/include/duckdb/common/helper.hpp b/src/duckdb/src/include/duckdb/common/helper.hpp index 758207c8d..5aad45ab1 100644 --- a/src/duckdb/src/include/duckdb/common/helper.hpp +++ b/src/duckdb/src/include/duckdb/common/helper.hpp @@ -195,6 +195,12 @@ static inline T AlignValue(T n) { return ((n + (val - 1)) / val) * val; } +template +inline data_ptr_t AlignValue(data_ptr_t addr) { + static_assert((alignment & (alignment - 1)) == 0, "'alignment' has to be a power of 2"); + return reinterpret_cast((reinterpret_cast(addr) + alignment - 1) & ~(alignment - 1)); +} + template constexpr inline T AlignValueFloor(T n) { return (n / val) * val; diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp index 5715d25db..5e4e62356 100644 --- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp +++ b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp @@ -236,6 +236,8 @@ class CSVSniffer { unordered_map> &best_sql_types_candidates_per_column_idx, CSVReaderOptions &options, CSVErrorHandler &error_handler); vector names; + //! If the file only has a header + bool single_row_file = false; //! ------------------------------------------------------// //! ------------------ Type Replacement ----------------- // diff --git a/src/duckdb/src/include/duckdb/function/scalar/strftime_format.hpp b/src/duckdb/src/include/duckdb/function/scalar/strftime_format.hpp index 7392be254..8353ee9a6 100644 --- a/src/duckdb/src/include/duckdb/function/scalar/strftime_format.hpp +++ b/src/duckdb/src/include/duckdb/function/scalar/strftime_format.hpp @@ -169,6 +169,7 @@ struct StrpTimeFormat : public StrTimeFormat { // NOLINT: work-around bug in cla return format_specifier != other.format_specifier; } DUCKDB_API static ParseResult Parse(const string &format, const string &text); + DUCKDB_API static bool TryParse(const string &format, const string &text, ParseResult &result); DUCKDB_API bool Parse(string_t str, ParseResult &result, bool strict = false) const; diff --git a/src/duckdb/src/include/duckdb/function/table/table_scan.hpp b/src/duckdb/src/include/duckdb/function/table/table_scan.hpp index 2a888a759..df4c829da 100644 --- a/src/duckdb/src/include/duckdb/function/table/table_scan.hpp +++ b/src/duckdb/src/include/duckdb/function/table/table_scan.hpp @@ -34,6 +34,13 @@ struct TableScanBindData : public TableFunctionData { auto &other = other_p.Cast(); return &other.table == &table; } + unique_ptr Copy() const override { + auto bind_data = make_uniq(table); + bind_data->is_index_scan = is_index_scan; + bind_data->is_create_index = is_create_index; + bind_data->column_ids = column_ids; + return std::move(bind_data); + } }; //! The table scan function represents a sequential or index scan over one of DuckDB's base tables. diff --git a/src/duckdb/src/include/duckdb/main/client_config.hpp b/src/duckdb/src/include/duckdb/main/client_config.hpp index 304d844f0..9cedb4074 100644 --- a/src/duckdb/src/include/duckdb/main/client_config.hpp +++ b/src/duckdb/src/include/duckdb/main/client_config.hpp @@ -120,6 +120,9 @@ struct ClientConfig { //! The maximum amount of OR filters we generate dynamically from a hash join idx_t dynamic_or_filter_threshold = 50; + //! The maximum amount of rows in the LIMIT/SAMPLE for which we trigger late materialization + idx_t late_materialization_max_rows = 50; + //! Whether the "/" division operator defaults to integer division or floating point division bool integer_division = false; //! When a scalar subquery returns multiple rows - return a random row instead of returning an error diff --git a/src/duckdb/src/include/duckdb/main/config.hpp b/src/duckdb/src/include/duckdb/main/config.hpp index 27e4b4b0e..ed88f334a 100644 --- a/src/duckdb/src/include/duckdb/main/config.hpp +++ b/src/duckdb/src/include/duckdb/main/config.hpp @@ -56,6 +56,7 @@ class CompressionInfo; class EncryptionUtil; struct CompressionFunctionSet; +struct DatabaseCacheEntry; struct DBConfig; enum class CheckpointAbort : uint8_t { @@ -331,6 +332,8 @@ struct DBConfig { vector> extension_callbacks; //! Encryption Util for OpenSSL shared_ptr encryption_util; + //! Reference to the database cache entry (if any) + shared_ptr db_cache_entry; public: DUCKDB_API static DBConfig &GetConfig(ClientContext &context); diff --git a/src/duckdb/src/include/duckdb/main/database.hpp b/src/duckdb/src/include/duckdb/main/database.hpp index 54884c563..ed956daa6 100644 --- a/src/duckdb/src/include/duckdb/main/database.hpp +++ b/src/duckdb/src/include/duckdb/main/database.hpp @@ -77,7 +77,6 @@ class DatabaseInstance : public enable_shared_from_this { const AttachOptions &options); void AddExtensionInfo(const string &name, const ExtensionLoadedInfo &info); - void SetDatabaseCacheEntry(shared_ptr entry); private: void Initialize(const char *path, DBConfig *config); @@ -95,7 +94,6 @@ class DatabaseInstance : public enable_shared_from_this { unordered_map loaded_extensions_info; ValidChecker db_validity; unique_ptr db_file_system; - shared_ptr db_cache_entry; shared_ptr log_manager; duckdb_ext_api_v1 (*create_api_v1)(); diff --git a/src/duckdb/src/include/duckdb/main/db_instance_cache.hpp b/src/duckdb/src/include/duckdb/main/db_instance_cache.hpp index b71d07e76..5eff82543 100644 --- a/src/duckdb/src/include/duckdb/main/db_instance_cache.hpp +++ b/src/duckdb/src/include/duckdb/main/db_instance_cache.hpp @@ -18,6 +18,7 @@ namespace duckdb { class DBInstanceCache; struct DatabaseCacheEntry { + DatabaseCacheEntry(); explicit DatabaseCacheEntry(const shared_ptr &database); ~DatabaseCacheEntry(); diff --git a/src/duckdb/src/include/duckdb/main/extension_entries.hpp b/src/duckdb/src/include/duckdb/main/extension_entries.hpp index b0d0c0c41..037e92272 100644 --- a/src/duckdb/src/include/duckdb/main/extension_entries.hpp +++ b/src/duckdb/src/include/duckdb/main/extension_entries.hpp @@ -645,6 +645,7 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = { {"st_zmax", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, {"st_zmflag", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, {"st_zmin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"start_ui", "motherduck", CatalogType::TABLE_FUNCTION_ENTRY}, {"starts_with", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, {"stats", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, {"stddev", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, diff --git a/src/duckdb/src/include/duckdb/main/settings.hpp b/src/duckdb/src/include/duckdb/main/settings.hpp index 98d4d4eb4..e5fe24520 100644 --- a/src/duckdb/src/include/duckdb/main/settings.hpp +++ b/src/duckdb/src/include/duckdb/main/settings.hpp @@ -783,6 +783,17 @@ struct IntegerDivisionSetting { static Value GetSetting(const ClientContext &context); }; +struct LateMaterializationMaxRowsSetting { + using RETURN_TYPE = idx_t; + static constexpr const char *Name = "late_materialization_max_rows"; + static constexpr const char *Description = + "The maximum amount of rows in the LIMIT/SAMPLE for which we trigger late materialization"; + 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); +}; + struct LockConfigurationSetting { using RETURN_TYPE = bool; static constexpr const char *Name = "lock_configuration"; diff --git a/src/duckdb/src/include/duckdb/optimizer/late_materialization.hpp b/src/duckdb/src/include/duckdb/optimizer/late_materialization.hpp new file mode 100644 index 000000000..76f4f05e8 --- /dev/null +++ b/src/duckdb/src/include/duckdb/optimizer/late_materialization.hpp @@ -0,0 +1,45 @@ +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/optimizer/late_materialization.hpp +// +// +//===----------------------------------------------------------------------===// + +#pragma once + +#include "duckdb/common/constants.hpp" +#include "duckdb/optimizer/remove_unused_columns.hpp" + +namespace duckdb { +class LogicalOperator; +class LogicalGet; +class Optimizer; + +//! Transform +class LateMaterialization : public BaseColumnPruner { +public: + explicit LateMaterialization(Optimizer &optimizer); + + unique_ptr Optimize(unique_ptr op); + +private: + bool TryLateMaterialization(unique_ptr &op); + + unique_ptr ConstructLHS(LogicalGet &get); + ColumnBinding ConstructRHS(unique_ptr &op); + idx_t GetOrInsertRowId(LogicalGet &get); + + void ReplaceTopLevelTableIndex(LogicalOperator &op, idx_t new_index); + void ReplaceTableReferences(Expression &expr, idx_t new_table_index); + unique_ptr GetExpression(LogicalOperator &op, idx_t column_index); + void ReplaceExpressionReferences(LogicalOperator &next_op, unique_ptr &expr); + bool OptimizeLargeLimit(LogicalOperator &child); + +private: + Optimizer &optimizer; + //! The max row count for which we will consider late materialization + idx_t max_row_count; +}; + +} // 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 a05a1d722..c2e5b1fc4 100644 --- a/src/duckdb/src/include/duckdb/optimizer/remove_unused_columns.hpp +++ b/src/duckdb/src/include/duckdb/optimizer/remove_unused_columns.hpp @@ -23,33 +23,18 @@ struct ReferencedColumn { vector child_columns; }; -//! The RemoveUnusedColumns optimizer traverses the logical operator tree and removes any columns that are not required -class RemoveUnusedColumns : public LogicalOperatorVisitor { -public: - RemoveUnusedColumns(Binder &binder, ClientContext &context, bool is_root = false) - : binder(binder), context(context), everything_referenced(is_root) { - } +class BaseColumnPruner : public LogicalOperatorVisitor { +protected: + //! The map of column references + column_binding_map_t column_references; - void VisitOperator(LogicalOperator &op) override; +protected: void VisitExpression(unique_ptr *expression) override; -protected: unique_ptr VisitReplace(BoundColumnRefExpression &expr, unique_ptr *expr_ptr) override; unique_ptr VisitReplace(BoundReferenceExpression &expr, unique_ptr *expr_ptr) override; -private: - Binder &binder; - ClientContext &context; - //! Whether or not all the columns are referenced. This happens in the case of the root expression (because the - //! output implicitly refers all the columns below it) - bool everything_referenced; - //! The map of column references - column_binding_map_t column_references; - -private: - template - void ClearUnusedExpressions(vector &list, idx_t table_idx, bool replace = true); - +protected: //! Add a reference to the column in its entirey void AddBinding(BoundColumnRefExpression &col); //! Add a reference to a sub-section of the column @@ -63,4 +48,25 @@ class RemoveUnusedColumns : public LogicalOperatorVisitor { bool HandleStructExtractRecursive(Expression &expr, optional_ptr &colref, vector &indexes); }; + +//! The RemoveUnusedColumns optimizer traverses the logical operator tree and removes any columns that are not required +class RemoveUnusedColumns : public BaseColumnPruner { +public: + RemoveUnusedColumns(Binder &binder, ClientContext &context, bool is_root = false) + : binder(binder), context(context), everything_referenced(is_root) { + } + + void VisitOperator(LogicalOperator &op) override; + +private: + Binder &binder; + ClientContext &context; + //! Whether or not all the columns are referenced. This happens in the case of the root expression (because the + //! output implicitly refers all the columns below it) + bool everything_referenced; + +private: + template + void ClearUnusedExpressions(vector &list, idx_t table_idx, bool replace = true); +}; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_get.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_get.hpp index 0a73d12cb..81b93accb 100644 --- a/src/duckdb/src/include/duckdb/planner/operator/logical_get.hpp +++ b/src/duckdb/src/include/duckdb/planner/operator/logical_get.hpp @@ -80,7 +80,7 @@ class LogicalGet : public LogicalOperator { void Serialize(Serializer &serializer) const override; static unique_ptr Deserialize(Deserializer &deserializer); - LogicalType GetRowIdType() const { + const LogicalType &GetRowIdType() const { return rowid_type; } diff --git a/src/duckdb/src/include/duckdb/storage/compression/roaring/roaring.hpp b/src/duckdb/src/include/duckdb/storage/compression/roaring/roaring.hpp index c20613744..da2fb5710 100644 --- a/src/duckdb/src/include/duckdb/storage/compression/roaring/roaring.hpp +++ b/src/duckdb/src/include/duckdb/storage/compression/roaring/roaring.hpp @@ -273,9 +273,9 @@ struct ContainerCompressionState { public: void Append(bool null, uint16_t amount = 1); - void OverrideArray(data_ptr_t destination, bool nulls, idx_t count); - void OverrideRun(data_ptr_t destination, idx_t count); - void OverrideUncompressed(data_ptr_t destination); + void OverrideArray(data_ptr_t &destination, bool nulls, idx_t count); + void OverrideRun(data_ptr_t &destination, idx_t count); + void OverrideUncompressed(data_ptr_t &destination); void Finalize(); ContainerMetadata GetResult(); void Reset(); diff --git a/src/duckdb/src/main/config.cpp b/src/duckdb/src/main/config.cpp index 286c72a3c..52a9ac2da 100644 --- a/src/duckdb/src/main/config.cpp +++ b/src/duckdb/src/main/config.cpp @@ -126,6 +126,7 @@ static const ConfigurationOption internal_options[] = { DUCKDB_GLOBAL(IndexScanMaxCountSetting), DUCKDB_GLOBAL(IndexScanPercentageSetting), DUCKDB_LOCAL(IntegerDivisionSetting), + DUCKDB_LOCAL(LateMaterializationMaxRowsSetting), DUCKDB_GLOBAL(LockConfigurationSetting), DUCKDB_LOCAL(LogQueryPathSetting), DUCKDB_GLOBAL(LoggingLevel), diff --git a/src/duckdb/src/main/database.cpp b/src/duckdb/src/main/database.cpp index f33b48c18..bed4269df 100644 --- a/src/duckdb/src/main/database.cpp +++ b/src/duckdb/src/main/database.cpp @@ -68,7 +68,9 @@ DatabaseInstance::DatabaseInstance() { DatabaseInstance::~DatabaseInstance() { // destroy all attached databases - GetDatabaseManager().ResetDatabases(scheduler); + if (db_manager) { + db_manager->ResetDatabases(scheduler); + } // destroy child elements connection_manager.reset(); object_cache.reset(); @@ -86,7 +88,7 @@ DatabaseInstance::~DatabaseInstance() { } Allocator::SetBackgroundThreads(false); // after all destruction is complete clear the cache entry - db_cache_entry.reset(); + config.db_cache_entry.reset(); } BufferManager &BufferManager::GetBufferManager(DatabaseInstance &db) { @@ -109,10 +111,6 @@ const DatabaseInstance &DatabaseInstance::GetDatabase(const ClientContext &conte return *context.db; } -void DatabaseInstance::SetDatabaseCacheEntry(shared_ptr entry) { - db_cache_entry = std::move(entry); -} - DatabaseManager &DatabaseInstance::GetDatabaseManager() { if (!db_manager) { throw InternalException("Missing DB manager"); @@ -464,6 +462,7 @@ void DatabaseInstance::Configure(DBConfig &new_config, const char *database_path config.options.buffer_manager_track_eviction_timestamps, config.options.allocator_bulk_deallocation_flush_threshold); } + config.db_cache_entry = new_config.db_cache_entry; } DBConfig &DBConfig::GetConfig(ClientContext &context) { diff --git a/src/duckdb/src/main/db_instance_cache.cpp b/src/duckdb/src/main/db_instance_cache.cpp index 062765b04..fa6059791 100644 --- a/src/duckdb/src/main/db_instance_cache.cpp +++ b/src/duckdb/src/main/db_instance_cache.cpp @@ -3,6 +3,9 @@ namespace duckdb { +DatabaseCacheEntry::DatabaseCacheEntry() { +} + DatabaseCacheEntry::DatabaseCacheEntry(const shared_ptr &database_p) : database(database_p) { } @@ -91,18 +94,22 @@ shared_ptr DBInstanceCache::CreateInstanceInternal(const string &databas if (abs_database_path.rfind(IN_MEMORY_PATH, 0) == 0) { instance_path = IN_MEMORY_PATH; } - auto db_instance = make_shared_ptr(instance_path, &config); - if (on_create) { - on_create(*db_instance); - } + shared_ptr cache_entry; if (cache_instance) { - // create the cache entry and attach it to the database - auto cache_entry = make_shared_ptr(db_instance); - db_instance->instance->SetDatabaseCacheEntry(cache_entry); + cache_entry = make_shared_ptr(); + config.db_cache_entry = cache_entry; + } + auto db_instance = make_shared_ptr(instance_path, &config); + if (cache_entry) { + // attach cache entry to the database + cache_entry->database = db_instance; // cache the entry in the db_instances map db_instances[abs_database_path] = cache_entry; } + if (on_create) { + on_create(*db_instance); + } return db_instance; } diff --git a/src/duckdb/src/main/settings/autogenerated_settings.cpp b/src/duckdb/src/main/settings/autogenerated_settings.cpp index 6a7106963..d007da71f 100644 --- a/src/duckdb/src/main/settings/autogenerated_settings.cpp +++ b/src/duckdb/src/main/settings/autogenerated_settings.cpp @@ -770,6 +770,23 @@ Value IntegerDivisionSetting::GetSetting(const ClientContext &context) { return Value::BOOLEAN(config.integer_division); } +//===----------------------------------------------------------------------===// +// Late Materialization Max Rows +//===----------------------------------------------------------------------===// +void LateMaterializationMaxRowsSetting::SetLocal(ClientContext &context, const Value &input) { + auto &config = ClientConfig::GetConfig(context); + config.late_materialization_max_rows = input.GetValue(); +} + +void LateMaterializationMaxRowsSetting::ResetLocal(ClientContext &context) { + ClientConfig::GetConfig(context).late_materialization_max_rows = ClientConfig().late_materialization_max_rows; +} + +Value LateMaterializationMaxRowsSetting::GetSetting(const ClientContext &context) { + auto &config = ClientConfig::GetConfig(context); + return Value::UBIGINT(config.late_materialization_max_rows); +} + //===----------------------------------------------------------------------===// // Lock Configuration //===----------------------------------------------------------------------===// diff --git a/src/duckdb/src/optimizer/late_materialization.cpp b/src/duckdb/src/optimizer/late_materialization.cpp new file mode 100644 index 000000000..81d4881cd --- /dev/null +++ b/src/duckdb/src/optimizer/late_materialization.cpp @@ -0,0 +1,414 @@ +#include "duckdb/optimizer/late_materialization.hpp" +#include "duckdb/planner/operator/logical_comparison_join.hpp" +#include "duckdb/planner/operator/logical_get.hpp" +#include "duckdb/planner/operator/logical_limit.hpp" +#include "duckdb/planner/operator/logical_order.hpp" +#include "duckdb/planner/operator/logical_projection.hpp" +#include "duckdb/planner/operator/logical_sample.hpp" +#include "duckdb/planner/operator/logical_top_n.hpp" +#include "duckdb/planner/expression/bound_columnref_expression.hpp" +#include "duckdb/planner/binder.hpp" +#include "duckdb/optimizer/optimizer.hpp" +#include "duckdb/planner/expression_iterator.hpp" +#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp" +#include "duckdb/main/client_config.hpp" + +namespace duckdb { + +LateMaterialization::LateMaterialization(Optimizer &optimizer) : optimizer(optimizer) { + max_row_count = ClientConfig::GetConfig(optimizer.context).late_materialization_max_rows; +} + +idx_t LateMaterialization::GetOrInsertRowId(LogicalGet &get) { + auto &column_ids = get.GetMutableColumnIds(); + // check if it is already projected + for (idx_t i = 0; i < column_ids.size(); ++i) { + if (column_ids[i].IsRowIdColumn()) { + // already projected - return the id + return i; + } + } + // row id is not yet projected - push it and return the new index + column_ids.push_back(ColumnIndex(COLUMN_IDENTIFIER_ROW_ID)); + if (!get.projection_ids.empty()) { + get.projection_ids.push_back(column_ids.size() - 1); + } + if (!get.types.empty()) { + get.types.push_back(get.GetRowIdType()); + } + return column_ids.size() - 1; +} + +unique_ptr LateMaterialization::ConstructLHS(LogicalGet &get) { + // we need to construct a new scan of the same table + auto table_index = optimizer.binder.GenerateTableIndex(); + auto new_get = make_uniq(table_index, get.function, get.bind_data->Copy(), get.returned_types, + get.names, get.GetRowIdType()); + new_get->GetMutableColumnIds() = get.GetColumnIds(); + new_get->projection_ids = get.projection_ids; + return new_get; +} + +ColumnBinding LateMaterialization::ConstructRHS(unique_ptr &op) { + // traverse down until we reach the LogicalGet + vector> stack; + reference child = *op->children[0]; + while (child.get().type != LogicalOperatorType::LOGICAL_GET) { + stack.push_back(child); + D_ASSERT(child.get().children.size() == 1); + child = *child.get().children[0]; + } + // we have reached the logical get - now we need to push the row-id column (if it is not yet projected out) + auto &get = child.get().Cast(); + auto row_id_idx = GetOrInsertRowId(get); + + // the row id has been projected - now project it up the stack + ColumnBinding row_id_binding(get.table_index, row_id_idx); + for (idx_t i = stack.size(); i > 0; i--) { + auto &op = stack[i - 1].get(); + switch (op.type) { + case LogicalOperatorType::LOGICAL_PROJECTION: { + auto &proj = op.Cast(); + // push a projection of the row-id column + proj.expressions.push_back( + make_uniq("rowid", get.GetRowIdType(), row_id_binding)); + // modify the row-id-binding to push to the new projection + row_id_binding = ColumnBinding(proj.table_index, proj.expressions.size() - 1); + break; + } + case LogicalOperatorType::LOGICAL_FILTER: + // column bindings pass-through this operator as-is + break; + default: + throw InternalException("Unsupported logical operator in LateMaterialization::ConstructRHS"); + } + } + return row_id_binding; +} + +void LateMaterialization::ReplaceTopLevelTableIndex(LogicalOperator &root, idx_t new_index) { + reference current_op = root; + while (true) { + auto &op = current_op.get(); + switch (op.type) { + case LogicalOperatorType::LOGICAL_PROJECTION: { + // reached a projection - modify the table index and return + auto &proj = op.Cast(); + proj.table_index = new_index; + return; + } + case LogicalOperatorType::LOGICAL_GET: { + // reached the root get - modify the table index and return + auto &get = op.Cast(); + get.table_index = new_index; + return; + } + case LogicalOperatorType::LOGICAL_TOP_N: { + // visit the expressions of the operator and continue into the child node + auto &top_n = op.Cast(); + for (auto &order : top_n.orders) { + ReplaceTableReferences(*order.expression, new_index); + } + current_op = *op.children[0]; + break; + } + case LogicalOperatorType::LOGICAL_FILTER: + case LogicalOperatorType::LOGICAL_SAMPLE: + case LogicalOperatorType::LOGICAL_LIMIT: { + // visit the expressions of the operator and continue into the child node + for (auto &expr : op.expressions) { + ReplaceTableReferences(*expr, new_index); + } + current_op = *op.children[0]; + break; + } + default: + throw InternalException("Unsupported operator type in LateMaterialization::ReplaceTopLevelTableIndex"); + } + } +} + +void LateMaterialization::ReplaceTableReferences(Expression &expr, idx_t new_table_index) { + if (expr.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) { + auto &bound_column_ref = expr.Cast(); + bound_column_ref.binding.table_index = new_table_index; + } + + ExpressionIterator::EnumerateChildren(expr, + [&](Expression &child) { ReplaceTableReferences(child, new_table_index); }); +} + +unique_ptr LateMaterialization::GetExpression(LogicalOperator &op, idx_t column_index) { + switch (op.type) { + case LogicalOperatorType::LOGICAL_GET: { + auto &get = op.Cast(); + auto &column_id = get.GetColumnIds()[column_index]; + auto is_row_id = column_id.IsRowIdColumn(); + auto column_name = is_row_id ? "rowid" : get.names[column_id.GetPrimaryIndex()]; + auto &column_type = is_row_id ? get.GetRowIdType() : get.returned_types[column_id.GetPrimaryIndex()]; + auto expr = + make_uniq(column_name, column_type, ColumnBinding(get.table_index, column_index)); + return std::move(expr); + } + case LogicalOperatorType::LOGICAL_PROJECTION: + return op.expressions[column_index]->Copy(); + default: + throw InternalException("Unsupported operator type for LateMaterialization::GetExpression"); + } +} + +void LateMaterialization::ReplaceExpressionReferences(LogicalOperator &next_op, unique_ptr &expr) { + if (expr->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) { + auto &bound_column_ref = expr->Cast(); + expr = GetExpression(next_op, bound_column_ref.binding.column_index); + return; + } + + ExpressionIterator::EnumerateChildren( + *expr, [&](unique_ptr &child) { ReplaceExpressionReferences(next_op, child); }); +} + +bool LateMaterialization::TryLateMaterialization(unique_ptr &op) { + // check if we can benefit from late materialization + // we need to see how many columns we require in the pipeline versus how many columns we emit in the scan + // for example, in a query like SELECT * FROM tbl ORDER BY ts LIMIT 5, the top-n only needs the "ts" column + // the other columns can be fetched later on using late materialization + // we can only push late materialization through a subset of operators + // and we can only do it for scans that support the row-id pushdown (currently only DuckDB table scans) + + // visit the expressions for each operator in the chain + vector> source_operators; + + VisitOperatorExpressions(*op); + reference child = *op->children[0]; + while (child.get().type != LogicalOperatorType::LOGICAL_GET) { + switch (child.get().type) { + case LogicalOperatorType::LOGICAL_PROJECTION: { + // recurse into the child node - but ONLY visit expressions that are referenced + auto &proj = child.get().Cast(); + source_operators.push_back(child); + + for (auto &expr : proj.expressions) { + if (expr->IsVolatile()) { + // we cannot do this optimization if any of the columns are volatile + return false; + } + } + + // figure out which projection expressions we are currently referencing + set referenced_columns; + for (auto &entry : column_references) { + auto &column_binding = entry.first; + if (column_binding.table_index == proj.table_index) { + referenced_columns.insert(column_binding.column_index); + } + } + // clear the list of referenced expressions and visit those columns + column_references.clear(); + for (auto &col_idx : referenced_columns) { + VisitExpression(&proj.expressions[col_idx]); + } + // continue into child + child = *child.get().children[0]; + break; + } + case LogicalOperatorType::LOGICAL_FILTER: + // visit filter expressions - we need these columns + VisitOperatorExpressions(child.get()); + // continue into child + child = *child.get().children[0]; + break; + default: + // unsupported operator for late materialization + return false; + } + } + auto &get = child.get().Cast(); + auto table = get.GetTable(); + if (!table || !table->IsDuckTable()) { + // we can only do the late-materialization optimization for DuckDB tables currently + return false; + } + if (column_references.size() >= get.GetColumnIds().size()) { + // we do not benefit from late materialization + // we need all of the columns to compute the root node anyway (Top-N/Limit/etc) + return false; + } + // we benefit from late materialization + // we need to transform this plan into a semi-join with the row-id + // we need to ensure the operator returns exactly the same column bindings as before + + // construct the LHS from the LogicalGet + auto lhs = ConstructLHS(get); + // insert the row-id column on the left hand side + auto &lhs_get = *lhs; + auto lhs_index = lhs_get.table_index; + auto lhs_columns = lhs_get.GetColumnIds().size(); + auto lhs_row_idx = GetOrInsertRowId(lhs_get); + ColumnBinding lhs_binding(lhs_index, lhs_row_idx); + + auto &row_id_type = get.GetRowIdType(); + + // after constructing the LHS but before constructing the RHS we construct the final projections/orders + // - we do this before constructing the RHS because that alter the original plan + vector> final_proj_list; + // construct the final projection list from either (1) the root projection, or (2) the logical get + if (!source_operators.empty()) { + // construct the columns from the root projection + auto &root_proj = source_operators[0].get(); + for (auto &expr : root_proj.expressions) { + final_proj_list.push_back(expr->Copy()); + } + // now we need to "flatten" the projection list by traversing the set of projections and inlining them + for (idx_t i = 0; i < source_operators.size(); i++) { + auto &next_operator = i + 1 < source_operators.size() ? source_operators[i + 1].get() : lhs_get; + for (auto &expr : final_proj_list) { + ReplaceExpressionReferences(next_operator, expr); + } + } + } else { + // if we have no projection directly construct the columns from the root get + for (idx_t i = 0; i < lhs_columns; i++) { + final_proj_list.push_back(GetExpression(lhs_get, i)); + } + } + + // we need to re-order again at the end + vector final_orders; + auto root_type = op->type; + if (root_type == LogicalOperatorType::LOGICAL_TOP_N) { + // for top-n we need to re-order by the top-n conditions + auto &top_n = op->Cast(); + for (auto &order : top_n.orders) { + auto expr = order.expression->Copy(); + final_orders.emplace_back(order.type, order.null_order, std::move(expr)); + } + } else { + // for limit/sample we order by row-id + auto row_id_expr = make_uniq("rowid", row_id_type, lhs_binding); + final_orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_LAST, std::move(row_id_expr)); + } + + // construct the RHS for the join + // this is essentially the old pipeline, but with the `rowid` column added + // note that the purpose of this optimization is to remove columns from the RHS + // we don't do that here yet though - we do this in a later step using the RemoveUnusedColumns optimizer + auto rhs_binding = ConstructRHS(op); + + // the final table index emitted must be the table index of the original operator + // this ensures any upstream operators that refer to the original get will keep on referring to the correct columns + auto final_index = rhs_binding.table_index; + + // we need to replace any references to "rhs_binding.table_index" in the rhs to a new table index + rhs_binding.table_index = optimizer.binder.GenerateTableIndex(); + ReplaceTopLevelTableIndex(*op, rhs_binding.table_index); + + // construct a semi join between the lhs and rhs + auto join = make_uniq(JoinType::SEMI); + join->children.push_back(std::move(lhs)); + join->children.push_back(std::move(op)); + JoinCondition condition; + condition.comparison = ExpressionType::COMPARE_EQUAL; + condition.left = make_uniq("rowid", row_id_type, lhs_binding); + condition.right = make_uniq("rowid", row_id_type, rhs_binding); + join->conditions.push_back(std::move(condition)); + + // push a projection that removes the row id again from the lhs + // this is the final projection - so it should have the final table index + auto proj_index = final_index; + if (root_type == LogicalOperatorType::LOGICAL_TOP_N) { + // for top-n we need to order on expressions, so we need to order AFTER the final projection + auto proj = make_uniq(proj_index, std::move(final_proj_list)); + proj->children.push_back(std::move(join)); + + for (auto &order : final_orders) { + ReplaceTableReferences(*order.expression, proj_index); + } + auto order = make_uniq(std::move(final_orders)); + order->children.push_back(std::move(proj)); + + op = std::move(order); + } else { + // for limit/sample we order on row-id, so we need to order BEFORE the final projection + // because the final projection removes row-ids + auto order = make_uniq(std::move(final_orders)); + order->children.push_back(std::move(join)); + + auto proj = make_uniq(proj_index, std::move(final_proj_list)); + proj->children.push_back(std::move(order)); + + op = std::move(proj); + } + + // run the RemoveUnusedColumns optimizer to prune the (now) unused columns the plan + RemoveUnusedColumns unused_optimizer(optimizer.binder, optimizer.context, true); + unused_optimizer.VisitOperator(*op); + return true; +} + +bool LateMaterialization::OptimizeLargeLimit(LogicalOperator &child) { + // we only support large limits if the only + reference current_op = child; + while (current_op.get().type != LogicalOperatorType::LOGICAL_GET) { + if (current_op.get().type != LogicalOperatorType::LOGICAL_PROJECTION) { + return false; + } + current_op = *current_op.get().children[0]; + } + return true; +} + +unique_ptr LateMaterialization::Optimize(unique_ptr op) { + switch (op->type) { + case LogicalOperatorType::LOGICAL_LIMIT: { + auto &limit = op->Cast(); + if (limit.limit_val.Type() != LimitNodeType::CONSTANT_VALUE) { + break; + } + if (limit.limit_val.GetConstantValue() > max_row_count) { + // for large limits - we may still want to do this optimization if the limit is consecutive + // this is the case if there are only projections/get below the limit + // if the row-ids are not consecutive doing the join can worsen performance + if (!OptimizeLargeLimit(*limit.children[0])) { + break; + } + } + if (TryLateMaterialization(op)) { + return op; + } + break; + } + case LogicalOperatorType::LOGICAL_TOP_N: { + auto &top_n = op->Cast(); + if (top_n.limit > max_row_count) { + break; + } + // for the top-n we need to visit the order elements + if (TryLateMaterialization(op)) { + return op; + } + break; + } + case LogicalOperatorType::LOGICAL_SAMPLE: { + auto &sample = op->Cast(); + if (sample.sample_options->is_percentage) { + break; + } + if (sample.sample_options->sample_size.GetValue() > max_row_count) { + break; + } + if (TryLateMaterialization(op)) { + return op; + } + break; + } + default: + break; + } + for (auto &child : op->children) { + child = Optimize(std::move(child)); + } + return op; +} + +} // namespace duckdb diff --git a/src/duckdb/src/optimizer/optimizer.cpp b/src/duckdb/src/optimizer/optimizer.cpp index d5c466211..8ac4cdd87 100644 --- a/src/duckdb/src/optimizer/optimizer.cpp +++ b/src/duckdb/src/optimizer/optimizer.cpp @@ -32,6 +32,7 @@ #include "duckdb/optimizer/sum_rewriter.hpp" #include "duckdb/optimizer/topn_optimizer.hpp" #include "duckdb/optimizer/unnest_rewriter.hpp" +#include "duckdb/optimizer/late_materialization.hpp" #include "duckdb/planner/binder.hpp" #include "duckdb/planner/planner.hpp" @@ -227,6 +228,12 @@ void Optimizer::RunBuiltInOptimizers() { plan = topn.Optimize(std::move(plan)); }); + // try to use late materialization + RunOptimizer(OptimizerType::LATE_MATERIALIZATION, [&]() { + LateMaterialization late_materialization(*this); + plan = late_materialization.Optimize(std::move(plan)); + }); + // perform statistics propagation column_binding_map_t> statistics_map; RunOptimizer(OptimizerType::STATISTICS_PROPAGATION, [&]() { diff --git a/src/duckdb/src/optimizer/remove_unused_columns.cpp b/src/duckdb/src/optimizer/remove_unused_columns.cpp index 3a867bdf2..b197a4f5f 100644 --- a/src/duckdb/src/optimizer/remove_unused_columns.cpp +++ b/src/duckdb/src/optimizer/remove_unused_columns.cpp @@ -23,7 +23,7 @@ namespace duckdb { -void RemoveUnusedColumns::ReplaceBinding(ColumnBinding current_binding, ColumnBinding new_binding) { +void BaseColumnPruner::ReplaceBinding(ColumnBinding current_binding, ColumnBinding new_binding) { auto colrefs = column_references.find(current_binding); if (colrefs != column_references.end()) { for (auto &colref_p : colrefs->second.bindings) { @@ -279,6 +279,7 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) { // Now set the projection cols by matching the "selection vector" that excludes filter columns // with the "selection vector" that includes filter columns idx_t col_idx = 0; + get.projection_ids.clear(); for (auto proj_sel_idx : proj_sel) { for (; col_idx < col_sel.size(); col_idx++) { if (proj_sel_idx == col_sel[col_idx]) { @@ -347,8 +348,8 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) { } } -bool RemoveUnusedColumns::HandleStructExtractRecursive(Expression &expr, optional_ptr &colref, - vector &indexes) { +bool BaseColumnPruner::HandleStructExtractRecursive(Expression &expr, optional_ptr &colref, + vector &indexes) { if (expr.GetExpressionClass() != ExpressionClass::BOUND_FUNCTION) { return false; } @@ -382,7 +383,7 @@ bool RemoveUnusedColumns::HandleStructExtractRecursive(Expression &expr, optiona return true; } -bool RemoveUnusedColumns::HandleStructExtract(Expression &expr) { +bool BaseColumnPruner::HandleStructExtract(Expression &expr) { optional_ptr colref; vector indexes; if (!HandleStructExtractRecursive(expr, colref, indexes)) { @@ -428,7 +429,7 @@ void MergeChildColumns(vector ¤t_child_columns, ColumnIndex & current_child_columns.push_back(std::move(new_child_column)); } -void RemoveUnusedColumns::AddBinding(BoundColumnRefExpression &col, ColumnIndex child_column) { +void BaseColumnPruner::AddBinding(BoundColumnRefExpression &col, ColumnIndex child_column) { auto entry = column_references.find(col.binding); if (entry == column_references.end()) { // column not referenced yet - add a binding to it entirely @@ -445,7 +446,7 @@ void RemoveUnusedColumns::AddBinding(BoundColumnRefExpression &col, ColumnIndex } } -void RemoveUnusedColumns::AddBinding(BoundColumnRefExpression &col) { +void BaseColumnPruner::AddBinding(BoundColumnRefExpression &col) { auto entry = column_references.find(col.binding); if (entry == column_references.end()) { // column not referenced yet - add a binding to it entirely @@ -458,7 +459,7 @@ void RemoveUnusedColumns::AddBinding(BoundColumnRefExpression &col) { } } -void RemoveUnusedColumns::VisitExpression(unique_ptr *expression) { +void BaseColumnPruner::VisitExpression(unique_ptr *expression) { auto &expr = **expression; if (HandleStructExtract(expr)) { // already handled @@ -468,15 +469,15 @@ void RemoveUnusedColumns::VisitExpression(unique_ptr *expression) { LogicalOperatorVisitor::VisitExpression(expression); } -unique_ptr RemoveUnusedColumns::VisitReplace(BoundColumnRefExpression &expr, - unique_ptr *expr_ptr) { +unique_ptr BaseColumnPruner::VisitReplace(BoundColumnRefExpression &expr, + unique_ptr *expr_ptr) { // add a reference to the entire column AddBinding(expr); return nullptr; } -unique_ptr RemoveUnusedColumns::VisitReplace(BoundReferenceExpression &expr, - unique_ptr *expr_ptr) { +unique_ptr BaseColumnPruner::VisitReplace(BoundReferenceExpression &expr, + unique_ptr *expr_ptr) { // BoundReferenceExpression should not be used here yet, they only belong in the physical plan throw InternalException("BoundReferenceExpression should not be used here yet!"); } diff --git a/src/duckdb/src/storage/compression/roaring/compress.cpp b/src/duckdb/src/storage/compression/roaring/compress.cpp index 77463d9e2..a7454d44d 100644 --- a/src/duckdb/src/storage/compression/roaring/compress.cpp +++ b/src/duckdb/src/storage/compression/roaring/compress.cpp @@ -100,7 +100,7 @@ void ContainerCompressionState::Append(bool null, uint16_t amount) { appended_count += amount; } -void ContainerCompressionState::OverrideArray(data_ptr_t destination, bool nulls, idx_t count) { +void ContainerCompressionState::OverrideArray(data_ptr_t &destination, bool nulls, idx_t count) { if (nulls) { append_function = AppendToArray; } else { @@ -110,28 +110,31 @@ void ContainerCompressionState::OverrideArray(data_ptr_t destination, bool nulls if (count >= COMPRESSED_ARRAY_THRESHOLD) { memset(destination, 0, sizeof(uint8_t) * COMPRESSED_SEGMENT_COUNT); array_counts[nulls] = reinterpret_cast(destination); - destination += sizeof(uint8_t) * COMPRESSED_SEGMENT_COUNT; - compressed_arrays[nulls] = reinterpret_cast(destination); + auto data_start = destination + sizeof(uint8_t) * COMPRESSED_SEGMENT_COUNT; + compressed_arrays[nulls] = reinterpret_cast(data_start); } else { + destination = AlignValue(destination); arrays[nulls] = reinterpret_cast(destination); } } -void ContainerCompressionState::OverrideRun(data_ptr_t destination, idx_t count) { +void ContainerCompressionState::OverrideRun(data_ptr_t &destination, idx_t count) { append_function = AppendRun; if (count >= COMPRESSED_RUN_THRESHOLD) { memset(destination, 0, sizeof(uint8_t) * COMPRESSED_SEGMENT_COUNT); run_counts = reinterpret_cast(destination); - destination += sizeof(uint8_t) * COMPRESSED_SEGMENT_COUNT; - compressed_runs = reinterpret_cast(destination); + auto data_start = destination + sizeof(uint8_t) * COMPRESSED_SEGMENT_COUNT; + compressed_runs = reinterpret_cast(data_start); } else { + destination = AlignValue(destination); runs = reinterpret_cast(destination); } } -void ContainerCompressionState::OverrideUncompressed(data_ptr_t destination) { +void ContainerCompressionState::OverrideUncompressed(data_ptr_t &destination) { append_function = AppendBitset; + destination = AlignValue(destination); uncompressed = reinterpret_cast(destination); } diff --git a/src/duckdb/src/storage/compression/roaring/scan.cpp b/src/duckdb/src/storage/compression/roaring/scan.cpp index 73ef83bfe..559f96779 100644 --- a/src/duckdb/src/storage/compression/roaring/scan.cpp +++ b/src/duckdb/src/storage/compression/roaring/scan.cpp @@ -224,6 +224,10 @@ RoaringScanState::RoaringScanState(ColumnSegment &segment) : segment(segment) { container_metadata.push_back(metadata); if (metadata.IsUncompressed()) { position = AlignValue(position); + } else if (metadata.IsArray() && metadata.Cardinality() < COMPRESSED_ARRAY_THRESHOLD) { + position = AlignValue(position); + } else if (metadata.IsRun() && metadata.NumberOfRuns() < COMPRESSED_RUN_THRESHOLD) { + position = AlignValue(position); } data_start_position.push_back(position); position += SkipVector(metadata); @@ -281,6 +285,7 @@ ContainerScanState &RoaringScanState::LoadContainer(idx_t container_index, idx_t current_container = make_uniq(container_index, container_size, number_of_runs, segments, data_ptr); } else { + D_ASSERT(AlignValue(data_ptr) == data_ptr); current_container = make_uniq(container_index, container_size, number_of_runs, data_ptr); } @@ -297,6 +302,7 @@ ContainerScanState &RoaringScanState::LoadContainer(idx_t container_index, idx_t container_index, container_size, cardinality, segments, data_ptr); } } else { + D_ASSERT(AlignValue(data_ptr) == data_ptr); if (metadata.IsInverted()) { current_container = make_uniq>(container_index, container_size, cardinality, data_ptr); diff --git a/src/duckdb/src/storage/table/row_group.cpp b/src/duckdb/src/storage/table/row_group.cpp index 38e173e83..d52503873 100644 --- a/src/duckdb/src/storage/table/row_group.cpp +++ b/src/duckdb/src/storage/table/row_group.cpp @@ -610,8 +610,8 @@ void RowGroup::TemplatedScan(TransactionData transaction, CollectionScanState &s const auto scan_idx = filter.scan_column_index; const auto column_idx = filter.table_column_index; + auto &result_vector = result.data[scan_idx]; if (column_idx == COLUMN_IDENTIFIER_ROW_ID) { - // We do another quick statistics scan for row ids here const auto rowid_start = this->start + current_row; const auto rowid_end = this->start + current_row + max_count; @@ -624,9 +624,9 @@ void RowGroup::TemplatedScan(TransactionData transaction, CollectionScanState &s // Generate row ids // Create sequence for row ids - D_ASSERT(result.data[i].GetType().InternalType() == ROW_TYPE); - result.data[i].SetVectorType(VectorType::FLAT_VECTOR); - auto result_data = FlatVector::GetData(result.data[i]); + D_ASSERT(result_vector.GetType().InternalType() == ROW_TYPE); + result_vector.SetVectorType(VectorType::FLAT_VECTOR); + auto result_data = FlatVector::GetData(result_vector); for (size_t sel_idx = 0; sel_idx < approved_tuple_count; sel_idx++) { result_data[sel.get_index(sel_idx)] = UnsafeNumericCast(this->start + current_row + sel.get_index(sel_idx)); @@ -639,14 +639,14 @@ void RowGroup::TemplatedScan(TransactionData transaction, CollectionScanState &s // Now apply the filter UnifiedVectorFormat vdata; - result.data[i].ToUnifiedFormat(approved_tuple_count, vdata); - ColumnSegment::FilterSelection(sel, result.data[i], vdata, filter.filter, approved_tuple_count, + result_vector.ToUnifiedFormat(approved_tuple_count, vdata); + ColumnSegment::FilterSelection(sel, result_vector, vdata, filter.filter, approved_tuple_count, approved_tuple_count); } else { auto &col_data = GetColumn(filter.table_column_index); - col_data.Filter(transaction, state.vector_index, state.column_scans[scan_idx], - result.data[scan_idx], sel, approved_tuple_count, filter.filter); + col_data.Filter(transaction, state.vector_index, state.column_scans[scan_idx], result_vector, + sel, approved_tuple_count, filter.filter); } } for (auto &table_filter : filter_list) { diff --git a/src/duckdb/ub_src_optimizer.cpp b/src/duckdb/ub_src_optimizer.cpp index 26f4abe53..05c18f993 100644 --- a/src/duckdb/ub_src_optimizer.cpp +++ b/src/duckdb/ub_src_optimizer.cpp @@ -30,6 +30,8 @@ #include "src/optimizer/join_filter_pushdown_optimizer.cpp" +#include "src/optimizer/late_materialization.cpp" + #include "src/optimizer/optimizer.cpp" #include "src/optimizer/regex_range_filter.cpp" From 9d02a507ebd9853e1c935413b5506ed87b3bf6eb Mon Sep 17 00:00:00 2001 From: DuckDB Labs GitHub Bot Date: Thu, 16 Jan 2025 00:33:07 +0000 Subject: [PATCH 14/16] Update vendored DuckDB sources to 4d88718b --- .../icu/common/bytestriebuilder.cpp | 2 +- .../icu/third_party/icu/common/dtintrv.cpp | 2 +- .../third_party/icu/common/filteredbrk.cpp | 2 +- .../icu/third_party/icu/common/locid.cpp | 2 +- .../icu/third_party/icu/common/lsr.cpp | 2 +- .../icu/third_party/icu/common/lsr.h | 4 +- .../third_party/icu/common/messagepattern.cpp | 4 +- .../icu/third_party/icu/common/normlzr.cpp | 2 +- .../icu/third_party/icu/common/rbbinode.h | 2 +- .../icu/third_party/icu/common/schriter.cpp | 2 +- .../icu/common/stringtriebuilder.cpp | 16 +- .../icu/common/ucharstriebuilder.cpp | 2 +- .../icu/third_party/icu/common/uchriter.cpp | 2 +- .../third_party/icu/common/unicode/brkiter.h | 4 +- .../icu/common/unicode/bytestriebuilder.h | 2 +- .../third_party/icu/common/unicode/chariter.h | 6 +- .../third_party/icu/common/unicode/dtintrv.h | 6 +- .../third_party/icu/common/unicode/locid.h | 6 +- .../icu/common/unicode/messagepattern.h | 8 +- .../third_party/icu/common/unicode/normlzr.h | 6 +- .../third_party/icu/common/unicode/parsepos.h | 8 +- .../icu/third_party/icu/common/unicode/rbbi.h | 4 +- .../third_party/icu/common/unicode/schriter.h | 2 +- .../third_party/icu/common/unicode/strenum.h | 4 +- .../icu/common/unicode/stringpiece.h | 2 +- .../icu/common/unicode/stringtriebuilder.h | 18 +- .../icu/common/unicode/ucharstriebuilder.h | 2 +- .../third_party/icu/common/unicode/uchriter.h | 2 +- .../third_party/icu/common/unicode/uniset.h | 6 +- .../third_party/icu/common/unicode/unistr.h | 24 +- .../third_party/icu/common/unicode/uobject.h | 4 +- .../icu/third_party/icu/common/unifiedcache.h | 8 +- .../icu/third_party/icu/common/uniset.cpp | 2 +- .../icu/common/ustr_titlecase_brkiter.cpp | 2 +- .../icu/third_party/icu/common/ustrenum.cpp | 4 +- .../icu/third_party/icu/common/uvector.cpp | 2 +- .../icu/third_party/icu/common/uvector.h | 6 +- .../icu/third_party/icu/common/uvectr32.cpp | 2 +- .../icu/third_party/icu/common/uvectr32.h | 6 +- .../icu/third_party/icu/common/uvectr64.cpp | 2 +- .../icu/third_party/icu/common/uvectr64.h | 6 +- .../icu/third_party/icu/i18n/alphaindex.cpp | 4 +- .../icu/third_party/icu/i18n/calendar.cpp | 2 +- .../icu/third_party/icu/i18n/choicfmt.cpp | 2 +- .../icu/third_party/icu/i18n/coleitr.cpp | 4 +- .../icu/third_party/icu/i18n/coll.cpp | 4 +- .../icu/i18n/collationiterator.cpp | 2 +- .../third_party/icu/i18n/collationiterator.h | 4 +- .../icu/i18n/collationsettings.cpp | 2 +- .../third_party/icu/i18n/collationsettings.h | 4 +- .../icu/third_party/icu/i18n/currpinf.cpp | 2 +- .../icu/third_party/icu/i18n/datefmt.cpp | 4 +- .../icu/third_party/icu/i18n/dcfmtsym.cpp | 2 +- .../icu/third_party/icu/i18n/decimfmt.cpp | 2 +- .../icu/third_party/icu/i18n/dtfmtsym.cpp | 2 +- .../icu/third_party/icu/i18n/dtitvfmt.cpp | 2 +- .../icu/third_party/icu/i18n/dtitvinf.cpp | 2 +- .../icu/third_party/icu/i18n/dtptngen.cpp | 4 +- .../icu/third_party/icu/i18n/dtptngen_impl.h | 8 +- .../icu/third_party/icu/i18n/dtrule.cpp | 4 +- .../icu/third_party/icu/i18n/fmtable.cpp | 2 +- .../icu/third_party/icu/i18n/format.cpp | 2 +- .../icu/third_party/icu/i18n/fpositer.cpp | 2 +- .../icu/third_party/icu/i18n/measfmt.cpp | 2 +- .../icu/third_party/icu/i18n/measunit.cpp | 2 +- .../icu/third_party/icu/i18n/measure.cpp | 2 +- .../icu/third_party/icu/i18n/msgfmt.cpp | 4 +- .../icu/third_party/icu/i18n/nfrs.cpp | 2 +- .../extension/icu/third_party/icu/i18n/nfrs.h | 4 +- .../icu/third_party/icu/i18n/nfrule.cpp | 2 +- .../icu/third_party/icu/i18n/nfrule.h | 4 +- .../icu/third_party/icu/i18n/nfsubs.cpp | 18 +- .../icu/third_party/icu/i18n/nfsubs.h | 4 +- .../third_party/icu/i18n/number_asformat.cpp | 2 +- .../third_party/icu/i18n/number_asformat.h | 2 +- .../icu/third_party/icu/i18n/numfmt.cpp | 2 +- .../icu/third_party/icu/i18n/olsontz.cpp | 2 +- .../icu/third_party/icu/i18n/olsontz.h | 2 +- .../icu/third_party/icu/i18n/plurfmt.cpp | 4 +- .../icu/third_party/icu/i18n/plurrule.cpp | 2 +- .../icu/third_party/icu/i18n/rbnf.cpp | 8 +- .../icu/third_party/icu/i18n/rbtz.cpp | 4 +- .../icu/third_party/icu/i18n/region.cpp | 4 +- .../icu/third_party/icu/i18n/reldtfmt.cpp | 2 +- .../icu/third_party/icu/i18n/reldtfmt.h | 2 +- .../icu/i18n/rulebasedcollator.cpp | 2 +- .../icu/third_party/icu/i18n/selfmt.cpp | 4 +- .../icu/third_party/icu/i18n/simpletz.cpp | 2 +- .../icu/third_party/icu/i18n/smpdtfmt.cpp | 2 +- .../icu/third_party/icu/i18n/sortkey.cpp | 2 +- .../icu/third_party/icu/i18n/timezone.cpp | 2 +- .../icu/third_party/icu/i18n/tmutamt.cpp | 2 +- .../icu/third_party/icu/i18n/tzfmt.cpp | 2 +- .../icu/third_party/icu/i18n/tzgnames.cpp | 2 +- .../icu/third_party/icu/i18n/tzgnames.h | 4 +- .../icu/third_party/icu/i18n/tznames.cpp | 6 +- .../icu/third_party/icu/i18n/tznames_impl.cpp | 4 +- .../icu/third_party/icu/i18n/tznames_impl.h | 4 +- .../icu/third_party/icu/i18n/tzrule.cpp | 16 +- .../icu/third_party/icu/i18n/tztrans.cpp | 4 +- .../third_party/icu/i18n/unicode/alphaindex.h | 4 +- .../third_party/icu/i18n/unicode/calendar.h | 4 +- .../third_party/icu/i18n/unicode/choicfmt.h | 2 +- .../third_party/icu/i18n/unicode/coleitr.h | 4 +- .../icu/third_party/icu/i18n/unicode/coll.h | 4 +- .../third_party/icu/i18n/unicode/currpinf.h | 6 +- .../third_party/icu/i18n/unicode/datefmt.h | 2 +- .../third_party/icu/i18n/unicode/dcfmtsym.h | 4 +- .../third_party/icu/i18n/unicode/decimfmt.h | 2 +- .../third_party/icu/i18n/unicode/dtfmtsym.h | 4 +- .../third_party/icu/i18n/unicode/dtitvfmt.h | 6 +- .../third_party/icu/i18n/unicode/dtitvinf.h | 6 +- .../third_party/icu/i18n/unicode/dtptngen.h | 4 +- .../icu/third_party/icu/i18n/unicode/dtrule.h | 4 +- .../third_party/icu/i18n/unicode/fieldpos.h | 8 +- .../third_party/icu/i18n/unicode/fmtable.h | 4 +- .../icu/third_party/icu/i18n/unicode/format.h | 4 +- .../third_party/icu/i18n/unicode/fpositer.h | 4 +- .../third_party/icu/i18n/unicode/measfmt.h | 2 +- .../third_party/icu/i18n/unicode/measunit.h | 4 +- .../third_party/icu/i18n/unicode/measure.h | 2 +- .../icu/third_party/icu/i18n/unicode/msgfmt.h | 4 +- .../icu/third_party/icu/i18n/unicode/numfmt.h | 2 +- .../third_party/icu/i18n/unicode/plurfmt.h | 4 +- .../third_party/icu/i18n/unicode/plurrule.h | 4 +- .../icu/third_party/icu/i18n/unicode/rbnf.h | 2 +- .../icu/third_party/icu/i18n/unicode/rbtz.h | 4 +- .../icu/third_party/icu/i18n/unicode/region.h | 4 +- .../icu/third_party/icu/i18n/unicode/search.h | 4 +- .../icu/third_party/icu/i18n/unicode/selfmt.h | 4 +- .../third_party/icu/i18n/unicode/simpletz.h | 2 +- .../third_party/icu/i18n/unicode/smpdtfmt.h | 2 +- .../third_party/icu/i18n/unicode/sortkey.h | 6 +- .../third_party/icu/i18n/unicode/stsearch.h | 2 +- .../third_party/icu/i18n/unicode/tblcoll.h | 2 +- .../third_party/icu/i18n/unicode/timezone.h | 4 +- .../third_party/icu/i18n/unicode/tmutamt.h | 6 +- .../third_party/icu/i18n/unicode/tmutfmt.h | 4 +- .../icu/third_party/icu/i18n/unicode/tzfmt.h | 2 +- .../third_party/icu/i18n/unicode/tznames.h | 4 +- .../icu/third_party/icu/i18n/unicode/tzrule.h | 16 +- .../third_party/icu/i18n/unicode/tztrans.h | 4 +- .../icu/third_party/icu/i18n/unicode/vtzone.h | 4 +- .../icu/i18n/utf16collationiterator.cpp | 4 +- .../icu/i18n/utf16collationiterator.h | 4 +- .../icu/third_party/icu/i18n/vtzone.cpp | 4 +- src/duckdb/extension/json/json_scan.cpp | 10 +- .../extension/parquet/column_writer.cpp | 33 ++- .../parquet/include/parquet_reader.hpp | 29 +- .../parquet/include/parquet_writer.hpp | 12 +- .../extension/parquet/parquet_extension.cpp | 268 +++++++++++------- .../extension/parquet/parquet_metadata.cpp | 6 +- .../extension/parquet/parquet_reader.cpp | 46 ++- .../extension/parquet/parquet_writer.cpp | 4 +- .../extension/parquet/serialize_parquet.cpp | 2 + .../src/common/arrow/arrow_type_extension.cpp | 24 +- src/duckdb/src/common/enum_util.cpp | 19 ++ src/duckdb/src/common/exception.cpp | 7 +- src/duckdb/src/common/multi_file_reader.cpp | 224 +++++++++++---- .../scanner/string_value_scanner.cpp | 17 +- .../table_function/csv_file_scanner.cpp | 66 +++-- .../table_function/global_csv_state.cpp | 10 +- .../operator/csv_scanner/util/csv_error.cpp | 4 +- .../function/table/version/pragma_version.cpp | 6 +- .../src/include/duckdb/common/enum_util.hpp | 8 + .../duckdb/common/multi_file_reader.hpp | 149 ++++++++-- .../common/multi_file_reader_options.hpp | 4 + .../operator/csv_scanner/csv_error.hpp | 2 +- .../operator/csv_scanner/csv_file_scanner.hpp | 12 +- .../expression/bound_parameter_data.hpp | 10 +- .../expression/bind_comparison_expression.cpp | 1 + .../planner/binder/statement/bind_execute.cpp | 3 +- src/duckdb/third_party/httplib/httplib.hpp | 1 - 173 files changed, 990 insertions(+), 575 deletions(-) diff --git a/src/duckdb/extension/icu/third_party/icu/common/bytestriebuilder.cpp b/src/duckdb/extension/icu/third_party/icu/common/bytestriebuilder.cpp index a1caf8310..038f2221a 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/bytestriebuilder.cpp +++ b/src/duckdb/extension/icu/third_party/icu/common/bytestriebuilder.cpp @@ -343,7 +343,7 @@ BytesTrieBuilder::BTLinearMatchNode::BTLinearMatchNode(const char *bytes, int32_ static_cast(hash)*37u + static_cast(ustr_hashCharsN(bytes, len))); } -UBool +bool BytesTrieBuilder::BTLinearMatchNode::operator==(const Node &other) const { if(this==&other) { return TRUE; diff --git a/src/duckdb/extension/icu/third_party/icu/common/dtintrv.cpp b/src/duckdb/extension/icu/third_party/icu/common/dtintrv.cpp index 80bb5d6db..011ad8136 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/dtintrv.cpp +++ b/src/duckdb/extension/icu/third_party/icu/common/dtintrv.cpp @@ -53,7 +53,7 @@ DateInterval::clone() const { } -UBool +bool DateInterval::operator==(const DateInterval& other) const { return ( fromDate == other.fromDate && toDate == other.toDate ); } diff --git a/src/duckdb/extension/icu/third_party/icu/common/filteredbrk.cpp b/src/duckdb/extension/icu/third_party/icu/common/filteredbrk.cpp index 1a003345b..59b914fbb 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/filteredbrk.cpp +++ b/src/duckdb/extension/icu/third_party/icu/common/filteredbrk.cpp @@ -175,7 +175,7 @@ // } // virtual SimpleFilteredSentenceBreakIterator* clone() const { return new SimpleFilteredSentenceBreakIterator(*this); } // virtual UClassID getDynamicClassID(void) const { return NULL; } -// virtual UBool operator==(const BreakIterator& o) const { if(this==&o) return true; return false; } +// virtual bool operator==(const BreakIterator& o) const { if(this==&o) return true; return false; } // /* -- text modifying -- */ // virtual void setText(UText *text, UErrorCode &status) { fDelegate->setText(text,status); } diff --git a/src/duckdb/extension/icu/third_party/icu/common/locid.cpp b/src/duckdb/extension/icu/third_party/icu/common/locid.cpp index 78292a87d..179d5b3b4 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/locid.cpp +++ b/src/duckdb/extension/icu/third_party/icu/common/locid.cpp @@ -482,7 +482,7 @@ Locale::clone() const { return new Locale(*this); } -UBool +bool Locale::operator==( const Locale& other) const { return (uprv_strcmp(other.fullName, fullName) == 0); diff --git a/src/duckdb/extension/icu/third_party/icu/common/lsr.cpp b/src/duckdb/extension/icu/third_party/icu/common/lsr.cpp index 0c28eeda1..8dca9dbbe 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/lsr.cpp +++ b/src/duckdb/extension/icu/third_party/icu/common/lsr.cpp @@ -60,7 +60,7 @@ LSR &LSR::operator=(LSR &&other) U_NOEXCEPT { return *this; } -UBool LSR::operator==(const LSR &other) const { +bool LSR::operator==(const LSR &other) const { return uprv_strcmp(language, other.language) == 0 && uprv_strcmp(script, other.script) == 0 && diff --git a/src/duckdb/extension/icu/third_party/icu/common/lsr.h b/src/duckdb/extension/icu/third_party/icu/common/lsr.h index db6cf938f..84769cf74 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/lsr.h +++ b/src/duckdb/extension/icu/third_party/icu/common/lsr.h @@ -55,9 +55,9 @@ struct LSR final : public UMemory { */ static int32_t indexForRegion(const char *region); - UBool operator==(const LSR &other) const; + bool operator==(const LSR &other) const; - inline UBool operator!=(const LSR &other) const { + inline bool operator!=(const LSR &other) const { return !operator==(other); } diff --git a/src/duckdb/extension/icu/third_party/icu/common/messagepattern.cpp b/src/duckdb/extension/icu/third_party/icu/common/messagepattern.cpp index f223d0671..b2956cb66 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/messagepattern.cpp +++ b/src/duckdb/extension/icu/third_party/icu/common/messagepattern.cpp @@ -309,7 +309,7 @@ MessagePattern::clear() { numericValuesLength=0; } -UBool +bool MessagePattern::operator==(const MessagePattern &other) const { if(this==&other) { return TRUE; @@ -387,7 +387,7 @@ MessagePattern::getPluralOffset(int32_t pluralStart) const { // MessagePattern::Part ---------------------------------------------------- *** -UBool +bool MessagePattern::Part::operator==(const Part &other) const { if(this==&other) { return TRUE; diff --git a/src/duckdb/extension/icu/third_party/icu/common/normlzr.cpp b/src/duckdb/extension/icu/third_party/icu/common/normlzr.cpp index 2dea0ffc3..1f4fa1517 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/normlzr.cpp +++ b/src/duckdb/extension/icu/third_party/icu/common/normlzr.cpp @@ -108,7 +108,7 @@ int32_t Normalizer::hashCode() const return text->hashCode() + fUMode + fOptions + buffer.hashCode() + bufferPos + currentIndex + nextIndex; } -UBool Normalizer::operator==(const Normalizer& that) const +bool Normalizer::operator==(const Normalizer& that) const { return this==&that || diff --git a/src/duckdb/extension/icu/third_party/icu/common/rbbinode.h b/src/duckdb/extension/icu/third_party/icu/common/rbbinode.h index f35259602..a30cccc0b 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/rbbinode.h +++ b/src/duckdb/extension/icu/third_party/icu/common/rbbinode.h @@ -108,7 +108,7 @@ class RBBINode : public UMemory { private: RBBINode &operator = (const RBBINode &other); // No defs. - UBool operator == (const RBBINode &other); // Private, so these functions won't accidently be used. + bool operator == (const RBBINode &other); // Private, so these functions won't accidently be used. #ifdef RBBI_DEBUG public: diff --git a/src/duckdb/extension/icu/third_party/icu/common/schriter.cpp b/src/duckdb/extension/icu/third_party/icu/common/schriter.cpp index 17b68aee9..f781bd43f 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/schriter.cpp +++ b/src/duckdb/extension/icu/third_party/icu/common/schriter.cpp @@ -79,7 +79,7 @@ StringCharacterIterator::operator=(const StringCharacterIterator& that) { return *this; } -UBool +bool StringCharacterIterator::operator==(const ForwardCharacterIterator& that) const { if (this == &that) { return TRUE; diff --git a/src/duckdb/extension/icu/third_party/icu/common/stringtriebuilder.cpp b/src/duckdb/extension/icu/third_party/icu/common/stringtriebuilder.cpp index 6f9cc2e5c..978ef9dbc 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/stringtriebuilder.cpp +++ b/src/duckdb/extension/icu/third_party/icu/common/stringtriebuilder.cpp @@ -383,7 +383,7 @@ StringTrieBuilder::equalNodes(const void *left, const void *right) { return *(const Node *)left==*(const Node *)right; } -UBool +bool StringTrieBuilder::Node::operator==(const Node &other) const { return this==&other || (typeid(*this)==typeid(other) && hash==other.hash); } @@ -396,7 +396,7 @@ StringTrieBuilder::Node::markRightEdgesFirst(int32_t edgeNumber) { return edgeNumber; } -UBool +bool StringTrieBuilder::FinalValueNode::operator==(const Node &other) const { if(this==&other) { return TRUE; @@ -413,7 +413,7 @@ StringTrieBuilder::FinalValueNode::write(StringTrieBuilder &builder) { offset=builder.writeValueAndFinal(value, TRUE); } -UBool +bool StringTrieBuilder::ValueNode::operator==(const Node &other) const { if(this==&other) { return TRUE; @@ -425,7 +425,7 @@ StringTrieBuilder::ValueNode::operator==(const Node &other) const { return hasValue==o.hasValue && (!hasValue || value==o.value); } -UBool +bool StringTrieBuilder::IntermediateValueNode::operator==(const Node &other) const { if(this==&other) { return TRUE; @@ -451,7 +451,7 @@ StringTrieBuilder::IntermediateValueNode::write(StringTrieBuilder &builder) { offset=builder.writeValueAndFinal(value, FALSE); } -UBool +bool StringTrieBuilder::LinearMatchNode::operator==(const Node &other) const { if(this==&other) { return TRUE; @@ -471,7 +471,7 @@ StringTrieBuilder::LinearMatchNode::markRightEdgesFirst(int32_t edgeNumber) { return edgeNumber; } -UBool +bool StringTrieBuilder::ListBranchNode::operator==(const Node &other) const { if(this==&other) { return TRUE; @@ -550,7 +550,7 @@ StringTrieBuilder::ListBranchNode::write(StringTrieBuilder &builder) { } } -UBool +bool StringTrieBuilder::SplitBranchNode::operator==(const Node &other) const { if(this==&other) { return TRUE; @@ -584,7 +584,7 @@ StringTrieBuilder::SplitBranchNode::write(StringTrieBuilder &builder) { offset=builder.write(unit); } -UBool +bool StringTrieBuilder::BranchHeadNode::operator==(const Node &other) const { if(this==&other) { return TRUE; diff --git a/src/duckdb/extension/icu/third_party/icu/common/ucharstriebuilder.cpp b/src/duckdb/extension/icu/third_party/icu/common/ucharstriebuilder.cpp index e7e7aed14..be4e386bb 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/ucharstriebuilder.cpp +++ b/src/duckdb/extension/icu/third_party/icu/common/ucharstriebuilder.cpp @@ -290,7 +290,7 @@ UCharsTrieBuilder::UCTLinearMatchNode::UCTLinearMatchNode(const UChar *units, in hash=hash*37u+ustr_hashUCharsN(units, len); } -UBool +bool UCharsTrieBuilder::UCTLinearMatchNode::operator==(const Node &other) const { if(this==&other) { return TRUE; diff --git a/src/duckdb/extension/icu/third_party/icu/common/uchriter.cpp b/src/duckdb/extension/icu/third_party/icu/common/uchriter.cpp index bedbabc74..ce248fbca 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/uchriter.cpp +++ b/src/duckdb/extension/icu/third_party/icu/common/uchriter.cpp @@ -66,7 +66,7 @@ UCharCharacterIterator::operator=(const UCharCharacterIterator& that) { UCharCharacterIterator::~UCharCharacterIterator() { } -UBool +bool UCharCharacterIterator::operator==(const ForwardCharacterIterator& that) const { if (this == &that) { return TRUE; diff --git a/src/duckdb/extension/icu/third_party/icu/common/unicode/brkiter.h b/src/duckdb/extension/icu/third_party/icu/common/unicode/brkiter.h index f7efdba77..321d47b55 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/unicode/brkiter.h +++ b/src/duckdb/extension/icu/third_party/icu/common/unicode/brkiter.h @@ -123,7 +123,7 @@ // * object, and styles are not considered. // * @stable ICU 2.0 // */ -// virtual UBool operator==(const BreakIterator&) const = 0; +// virtual bool operator==(const BreakIterator&) const = 0; // /** // * Returns the complement of the result of operator== @@ -131,7 +131,7 @@ // * @return the complement of the result of operator== // * @stable ICU 2.0 // */ -// UBool operator!=(const BreakIterator& rhs) const { return !operator==(rhs); } +// bool operator!=(const BreakIterator& rhs) const { return !operator==(rhs); } // /** // * Return a polymorphic copy of this object. This is an abstract diff --git a/src/duckdb/extension/icu/third_party/icu/common/unicode/bytestriebuilder.h b/src/duckdb/extension/icu/third_party/icu/common/unicode/bytestriebuilder.h index b98374bb8..67dbbf74c 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/unicode/bytestriebuilder.h +++ b/src/duckdb/extension/icu/third_party/icu/common/unicode/bytestriebuilder.h @@ -151,7 +151,7 @@ class U_COMMON_API BytesTrieBuilder : public StringTrieBuilder { class BTLinearMatchNode : public LinearMatchNode { public: BTLinearMatchNode(const char *units, int32_t len, Node *nextNode); - virtual UBool operator==(const Node &other) const; + virtual bool operator==(const Node &other) const; virtual void write(StringTrieBuilder &builder); private: const char *s; diff --git a/src/duckdb/extension/icu/third_party/icu/common/unicode/chariter.h b/src/duckdb/extension/icu/third_party/icu/common/unicode/chariter.h index db86f79e4..5b00e6622 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/unicode/chariter.h +++ b/src/duckdb/extension/icu/third_party/icu/common/unicode/chariter.h @@ -114,7 +114,7 @@ class U_COMMON_API ForwardCharacterIterator : public UObject { * character in the same character-storage object * @stable ICU 2.0 */ - virtual UBool operator==(const ForwardCharacterIterator& that) const = 0; + virtual bool operator==(const ForwardCharacterIterator& that) const = 0; /** * Returns true when the iterators refer to different @@ -126,7 +126,7 @@ class U_COMMON_API ForwardCharacterIterator : public UObject { * same text-storage object * @stable ICU 2.0 */ - inline UBool operator!=(const ForwardCharacterIterator& that) const; + inline bool operator!=(const ForwardCharacterIterator& that) const; /** * Generates a hash code for this iterator. @@ -692,7 +692,7 @@ class U_COMMON_API CharacterIterator : public ForwardCharacterIterator { int32_t end; }; -inline UBool +inline bool ForwardCharacterIterator::operator!=(const ForwardCharacterIterator& that) const { return !operator==(that); } diff --git a/src/duckdb/extension/icu/third_party/icu/common/unicode/dtintrv.h b/src/duckdb/extension/icu/third_party/icu/common/unicode/dtintrv.h index 15e15c9d4..fb3f531e9 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/unicode/dtintrv.h +++ b/src/duckdb/extension/icu/third_party/icu/common/unicode/dtintrv.h @@ -109,14 +109,14 @@ class U_COMMON_API DateInterval : public UObject { * @return TRUE if the two DateIntervals are the same * @stable ICU 4.0 */ - virtual UBool operator==(const DateInterval& other) const; + virtual bool operator==(const DateInterval& other) const; /** * Non-equality operator * @return TRUE if the two DateIntervals are not the same * @stable ICU 4.0 */ - inline UBool operator!=(const DateInterval& other) const; + inline bool operator!=(const DateInterval& other) const; /** @@ -151,7 +151,7 @@ DateInterval::getToDate() const { } -inline UBool +inline bool DateInterval::operator!=(const DateInterval& other) const { return ( !operator==(other) ); } diff --git a/src/duckdb/extension/icu/third_party/icu/common/unicode/locid.h b/src/duckdb/extension/icu/third_party/icu/common/unicode/locid.h index 57c669b33..210e4f425 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/unicode/locid.h +++ b/src/duckdb/extension/icu/third_party/icu/common/unicode/locid.h @@ -329,7 +329,7 @@ class U_COMMON_API Locale : public UObject { * @return True if the two locale keys are the same, false otherwise. * @stable ICU 2.0 */ - UBool operator==(const Locale& other) const; + bool operator==(const Locale& other) const; /** * Checks if two locale keys are not the same. @@ -339,7 +339,7 @@ class U_COMMON_API Locale : public UObject { * otherwise. * @stable ICU 2.0 */ - inline UBool operator!=(const Locale& other) const; + inline bool operator!=(const Locale& other) const; /** * Clone this object. @@ -1153,7 +1153,7 @@ class U_COMMON_API Locale : public UObject { friend void U_CALLCONV locale_available_init(); }; -inline UBool +inline bool Locale::operator!=(const Locale& other) const { return !operator==(other); diff --git a/src/duckdb/extension/icu/third_party/icu/common/unicode/messagepattern.h b/src/duckdb/extension/icu/third_party/icu/common/unicode/messagepattern.h index 04f00a875..3084c4267 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/unicode/messagepattern.h +++ b/src/duckdb/extension/icu/third_party/icu/common/unicode/messagepattern.h @@ -526,14 +526,14 @@ class U_COMMON_API MessagePattern : public UObject { * @return TRUE if this object is equivalent to the other one. * @stable ICU 4.8 */ - UBool operator==(const MessagePattern &other) const; + bool operator==(const MessagePattern &other) const; /** * @param other another object to compare with. * @return FALSE if this object is equivalent to the other one. * @stable ICU 4.8 */ - inline UBool operator!=(const MessagePattern &other) const { + inline bool operator!=(const MessagePattern &other) const { return !operator==(other); } @@ -797,14 +797,14 @@ class U_COMMON_API MessagePattern : public UObject { * @return TRUE if this object is equivalent to the other one. * @stable ICU 4.8 */ - UBool operator==(const Part &other) const; + bool operator==(const Part &other) const; /** * @param other another object to compare with. * @return FALSE if this object is equivalent to the other one. * @stable ICU 4.8 */ - inline UBool operator!=(const Part &other) const { + inline bool operator!=(const Part &other) const { return !operator==(other); } diff --git a/src/duckdb/extension/icu/third_party/icu/common/unicode/normlzr.h b/src/duckdb/extension/icu/third_party/icu/common/unicode/normlzr.h index 07a596bd1..14729720d 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/unicode/normlzr.h +++ b/src/duckdb/extension/icu/third_party/icu/common/unicode/normlzr.h @@ -584,7 +584,7 @@ class U_COMMON_API Normalizer : public UObject { * @return comparison result * @deprecated ICU 56 Use Normalizer2 instead. */ - UBool operator==(const Normalizer& that) const; + bool operator==(const Normalizer& that) const; /** * Returns FALSE when both iterators refer to the same character in the same @@ -594,7 +594,7 @@ class U_COMMON_API Normalizer : public UObject { * @return comparison result * @deprecated ICU 56 Use Normalizer2 instead. */ - inline UBool operator!=(const Normalizer& that) const; + inline bool operator!=(const Normalizer& that) const; /** * Returns a pointer to a new Normalizer that is a clone of this one. @@ -777,7 +777,7 @@ class U_COMMON_API Normalizer : public UObject { //------------------------------------------------------------------------- #ifndef U_HIDE_DEPRECATED_API -inline UBool +inline bool Normalizer::operator!= (const Normalizer& other) const { return ! operator==(other); } diff --git a/src/duckdb/extension/icu/third_party/icu/common/unicode/parsepos.h b/src/duckdb/extension/icu/third_party/icu/common/unicode/parsepos.h index 909d288d4..76c3fd282 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/unicode/parsepos.h +++ b/src/duckdb/extension/icu/third_party/icu/common/unicode/parsepos.h @@ -100,14 +100,14 @@ class U_COMMON_API ParsePosition : public UObject { * @return TRUE if the two parse positions are equal, FALSE otherwise. * @stable ICU 2.0 */ - inline UBool operator==(const ParsePosition& that) const; + inline bool operator==(const ParsePosition& that) const; /** * Equality operator. * @return TRUE if the two parse positions are not equal, FALSE otherwise. * @stable ICU 2.0 */ - inline UBool operator!=(const ParsePosition& that) const; + inline bool operator!=(const ParsePosition& that) const; /** * Clone this object. @@ -192,7 +192,7 @@ ParsePosition::operator=(const ParsePosition& copy) return *this; } -inline UBool +inline bool ParsePosition::operator==(const ParsePosition& copy) const { if(index != copy.index || errorIndex != copy.errorIndex) @@ -201,7 +201,7 @@ ParsePosition::operator==(const ParsePosition& copy) const return TRUE; } -inline UBool +inline bool ParsePosition::operator!=(const ParsePosition& copy) const { return !operator==(copy); diff --git a/src/duckdb/extension/icu/third_party/icu/common/unicode/rbbi.h b/src/duckdb/extension/icu/third_party/icu/common/unicode/rbbi.h index dcff281ff..978539625 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/unicode/rbbi.h +++ b/src/duckdb/extension/icu/third_party/icu/common/unicode/rbbi.h @@ -253,7 +253,7 @@ // * same class, have the same behavior, and iterate over the same text. // * @stable ICU 2.0 // */ -// virtual UBool operator==(const BreakIterator& that) const; +// virtual bool operator==(const BreakIterator& that) const; // /** // * Not-equal operator. If operator== returns TRUE, this returns FALSE, @@ -262,7 +262,7 @@ // * @return TRUE if both BreakIterators are not same. // * @stable ICU 2.0 // */ -// inline UBool operator!=(const BreakIterator& that) const; +// inline bool operator!=(const BreakIterator& that) const; // /** // * Returns a newly-constructed RuleBasedBreakIterator with the same diff --git a/src/duckdb/extension/icu/third_party/icu/common/unicode/schriter.h b/src/duckdb/extension/icu/third_party/icu/common/unicode/schriter.h index 1ca5b70fc..024c80b89 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/unicode/schriter.h +++ b/src/duckdb/extension/icu/third_party/icu/common/unicode/schriter.h @@ -124,7 +124,7 @@ class U_COMMON_API StringCharacterIterator : public UCharCharacterIterator { * same string and are pointing at the same character. * @stable ICU 2.0 */ - virtual UBool operator==(const ForwardCharacterIterator& that) const; + virtual bool operator==(const ForwardCharacterIterator& that) const; /** * Returns a new StringCharacterIterator referring to the same diff --git a/src/duckdb/extension/icu/third_party/icu/common/unicode/strenum.h b/src/duckdb/extension/icu/third_party/icu/common/unicode/strenum.h index 8601f1f7c..e6b932224 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/unicode/strenum.h +++ b/src/duckdb/extension/icu/third_party/icu/common/unicode/strenum.h @@ -199,7 +199,7 @@ class U_COMMON_API StringEnumeration : public UObject { * @return TRUE if the enumerations are equal. FALSE if not. * @stable ICU 3.6 */ - virtual UBool operator==(const StringEnumeration& that)const; + virtual bool operator==(const StringEnumeration& that)const; /** * Compares this enumeration to other to check if both are not equal * @@ -207,7 +207,7 @@ class U_COMMON_API StringEnumeration : public UObject { * @return TRUE if the enumerations are equal. FALSE if not. * @stable ICU 3.6 */ - virtual UBool operator!=(const StringEnumeration& that)const; + virtual bool operator!=(const StringEnumeration& that)const; protected: /** diff --git a/src/duckdb/extension/icu/third_party/icu/common/unicode/stringpiece.h b/src/duckdb/extension/icu/third_party/icu/common/unicode/stringpiece.h index f581091f8..3025f3294 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/unicode/stringpiece.h +++ b/src/duckdb/extension/icu/third_party/icu/common/unicode/stringpiece.h @@ -248,7 +248,7 @@ operator==(const StringPiece& x, const StringPiece& y); * @return TRUE if the string data is not equal * @stable ICU 4.8 */ -inline UBool operator!=(const StringPiece& x, const StringPiece& y) { +inline bool operator!=(const StringPiece& x, const StringPiece& y) { return !(x == y); } diff --git a/src/duckdb/extension/icu/third_party/icu/common/unicode/stringtriebuilder.h b/src/duckdb/extension/icu/third_party/icu/common/unicode/stringtriebuilder.h index 2c47dd415..dc00a7c39 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/unicode/stringtriebuilder.h +++ b/src/duckdb/extension/icu/third_party/icu/common/unicode/stringtriebuilder.h @@ -204,8 +204,8 @@ class U_COMMON_API StringTrieBuilder : public UObject { // Handles node==NULL. static inline int32_t hashCode(const Node *node) { return node==NULL ? 0 : node->hashCode(); } // Base class operator==() compares the actual class types. - virtual UBool operator==(const Node &other) const; - inline UBool operator!=(const Node &other) const { return !operator==(other); } + virtual bool operator==(const Node &other) const; + inline bool operator!=(const Node &other) const { return !operator==(other); } /** * Traverses the Node graph and numbers branch edges, with rightmost edges first. * This is to avoid writing a duplicate node twice. @@ -265,7 +265,7 @@ class U_COMMON_API StringTrieBuilder : public UObject { class FinalValueNode : public Node { public: FinalValueNode(int32_t v) : Node(0x111111u*37u+v), value(v) {} - virtual UBool operator==(const Node &other) const; + virtual bool operator==(const Node &other) const; virtual void write(StringTrieBuilder &builder); protected: int32_t value; @@ -280,7 +280,7 @@ class U_COMMON_API StringTrieBuilder : public UObject { class ValueNode : public Node { public: ValueNode(int32_t initialHash) : Node(initialHash), hasValue(FALSE), value(0) {} - virtual UBool operator==(const Node &other) const; + virtual bool operator==(const Node &other) const; void setValue(int32_t v) { hasValue=TRUE; value=v; @@ -299,7 +299,7 @@ class U_COMMON_API StringTrieBuilder : public UObject { public: IntermediateValueNode(int32_t v, Node *nextNode) : ValueNode(0x222222u*37u+hashCode(nextNode)), next(nextNode) { setValue(v); } - virtual UBool operator==(const Node &other) const; + virtual bool operator==(const Node &other) const; virtual int32_t markRightEdgesFirst(int32_t edgeNumber); virtual void write(StringTrieBuilder &builder); protected: @@ -317,7 +317,7 @@ class U_COMMON_API StringTrieBuilder : public UObject { LinearMatchNode(int32_t len, Node *nextNode) : ValueNode((0x333333u*37u+len)*37u+hashCode(nextNode)), length(len), next(nextNode) {} - virtual UBool operator==(const Node &other) const; + virtual bool operator==(const Node &other) const; virtual int32_t markRightEdgesFirst(int32_t edgeNumber); protected: int32_t length; @@ -341,7 +341,7 @@ class U_COMMON_API StringTrieBuilder : public UObject { class ListBranchNode : public BranchNode { public: ListBranchNode() : BranchNode(0x444444), length(0) {} - virtual UBool operator==(const Node &other) const; + virtual bool operator==(const Node &other) const; virtual int32_t markRightEdgesFirst(int32_t edgeNumber); virtual void write(StringTrieBuilder &builder); // Adds a unit with a final value. @@ -376,7 +376,7 @@ class U_COMMON_API StringTrieBuilder : public UObject { : BranchNode(((0x555555u*37u+middleUnit)*37u+ hashCode(lessThanNode))*37u+hashCode(greaterOrEqualNode)), unit(middleUnit), lessThan(lessThanNode), greaterOrEqual(greaterOrEqualNode) {} - virtual UBool operator==(const Node &other) const; + virtual bool operator==(const Node &other) const; virtual int32_t markRightEdgesFirst(int32_t edgeNumber); virtual void write(StringTrieBuilder &builder); protected: @@ -392,7 +392,7 @@ class U_COMMON_API StringTrieBuilder : public UObject { BranchHeadNode(int32_t len, Node *subNode) : ValueNode((0x666666u*37u+len)*37u+hashCode(subNode)), length(len), next(subNode) {} - virtual UBool operator==(const Node &other) const; + virtual bool operator==(const Node &other) const; virtual int32_t markRightEdgesFirst(int32_t edgeNumber); virtual void write(StringTrieBuilder &builder); protected: diff --git a/src/duckdb/extension/icu/third_party/icu/common/unicode/ucharstriebuilder.h b/src/duckdb/extension/icu/third_party/icu/common/unicode/ucharstriebuilder.h index 540dcc047..f01853954 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/unicode/ucharstriebuilder.h +++ b/src/duckdb/extension/icu/third_party/icu/common/unicode/ucharstriebuilder.h @@ -156,7 +156,7 @@ class U_COMMON_API UCharsTrieBuilder : public StringTrieBuilder { class UCTLinearMatchNode : public LinearMatchNode { public: UCTLinearMatchNode(const char16_t *units, int32_t len, Node *nextNode); - virtual UBool operator==(const Node &other) const; + virtual bool operator==(const Node &other) const; virtual void write(StringTrieBuilder &builder); private: const char16_t *s; diff --git a/src/duckdb/extension/icu/third_party/icu/common/unicode/uchriter.h b/src/duckdb/extension/icu/third_party/icu/common/unicode/uchriter.h index a485259b8..f6979e2bc 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/unicode/uchriter.h +++ b/src/duckdb/extension/icu/third_party/icu/common/unicode/uchriter.h @@ -119,7 +119,7 @@ class U_COMMON_API UCharCharacterIterator : public CharacterIterator { * same string and are pointing at the same character. * @stable ICU 2.0 */ - virtual UBool operator==(const ForwardCharacterIterator& that) const; + virtual bool operator==(const ForwardCharacterIterator& that) const; /** * Generates a hash code for this iterator. diff --git a/src/duckdb/extension/icu/third_party/icu/common/unicode/uniset.h b/src/duckdb/extension/icu/third_party/icu/common/unicode/uniset.h index 18cc93764..623f8087e 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/unicode/uniset.h +++ b/src/duckdb/extension/icu/third_party/icu/common/unicode/uniset.h @@ -487,14 +487,14 @@ class U_COMMON_API UnicodeSet U_FINAL : public UnicodeFilter { * @return true if the specified set is equal to this set. * @stable ICU 2.0 */ - virtual UBool operator==(const UnicodeSet& o) const; + virtual bool operator==(const UnicodeSet& o) const; /** * Compares the specified object with this set for equality. Returns * true if the specified set is not equal to this set. * @stable ICU 2.0 */ - inline UBool operator!=(const UnicodeSet& o) const; + inline bool operator!=(const UnicodeSet& o) const; /** * Returns a copy of this object. All UnicodeFunctor objects have @@ -1677,7 +1677,7 @@ class U_COMMON_API UnicodeSet U_FINAL : public UnicodeFilter { -inline UBool UnicodeSet::operator!=(const UnicodeSet& o) const { +inline bool UnicodeSet::operator!=(const UnicodeSet& o) const { return !operator==(o); } diff --git a/src/duckdb/extension/icu/third_party/icu/common/unicode/unistr.h b/src/duckdb/extension/icu/third_party/icu/common/unicode/unistr.h index 368ce2c6e..b7c87e6b8 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/unicode/unistr.h +++ b/src/duckdb/extension/icu/third_party/icu/common/unicode/unistr.h @@ -324,7 +324,7 @@ class U_COMMON_API UnicodeString : public Replaceable * FALSE otherwise. * @stable ICU 2.0 */ - inline UBool operator== (const UnicodeString& text) const; + inline bool operator== (const UnicodeString& text) const; /** * Inequality operator. Performs only bitwise comparison. @@ -333,7 +333,7 @@ class U_COMMON_API UnicodeString : public Replaceable * TRUE otherwise. * @stable ICU 2.0 */ - inline UBool operator!= (const UnicodeString& text) const; + inline bool operator!= (const UnicodeString& text) const; /** * Greater than operator. Performs only bitwise comparison. @@ -342,7 +342,7 @@ class U_COMMON_API UnicodeString : public Replaceable * greater than the characters in `text`, FALSE otherwise * @stable ICU 2.0 */ - inline UBool operator> (const UnicodeString& text) const; + inline bool operator> (const UnicodeString& text) const; /** * Less than operator. Performs only bitwise comparison. @@ -351,7 +351,7 @@ class U_COMMON_API UnicodeString : public Replaceable * less than the characters in `text`, FALSE otherwise * @stable ICU 2.0 */ - inline UBool operator< (const UnicodeString& text) const; + inline bool operator< (const UnicodeString& text) const; /** * Greater than or equal operator. Performs only bitwise comparison. @@ -360,7 +360,7 @@ class U_COMMON_API UnicodeString : public Replaceable * greater than or equal to the characters in `text`, FALSE otherwise * @stable ICU 2.0 */ - inline UBool operator>= (const UnicodeString& text) const; + inline bool operator>= (const UnicodeString& text) const; /** * Less than or equal operator. Performs only bitwise comparison. @@ -369,7 +369,7 @@ class U_COMMON_API UnicodeString : public Replaceable * less than or equal to the characters in `text`, FALSE otherwise * @stable ICU 2.0 */ - inline UBool operator<= (const UnicodeString& text) const; + inline bool operator<= (const UnicodeString& text) const; /** * Compare the characters bitwise in this UnicodeString to @@ -3946,7 +3946,7 @@ UnicodeString::doCompare(int32_t start, } } -inline UBool +inline bool UnicodeString::operator== (const UnicodeString& text) const { if(isBogus()) { @@ -3957,23 +3957,23 @@ UnicodeString::operator== (const UnicodeString& text) const } } -inline UBool +inline bool UnicodeString::operator!= (const UnicodeString& text) const { return (! operator==(text)); } -inline UBool +inline bool UnicodeString::operator> (const UnicodeString& text) const { return doCompare(0, length(), text, 0, text.length()) == 1; } -inline UBool +inline bool UnicodeString::operator< (const UnicodeString& text) const { return doCompare(0, length(), text, 0, text.length()) == -1; } -inline UBool +inline bool UnicodeString::operator>= (const UnicodeString& text) const { return doCompare(0, length(), text, 0, text.length()) != -1; } -inline UBool +inline bool UnicodeString::operator<= (const UnicodeString& text) const { return doCompare(0, length(), text, 0, text.length()) != 1; } diff --git a/src/duckdb/extension/icu/third_party/icu/common/unicode/uobject.h b/src/duckdb/extension/icu/third_party/icu/common/unicode/uobject.h index eeb331ce9..25a8330f9 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/unicode/uobject.h +++ b/src/duckdb/extension/icu/third_party/icu/common/unicode/uobject.h @@ -262,8 +262,8 @@ class U_COMMON_API UObject : public UMemory { // UObject &operator=(const UObject &other) { return *this; } // comparison operators - virtual inline UBool operator==(const UObject &other) const { return this==&other; } - inline UBool operator!=(const UObject &other) const { return !operator==(other); } + virtual inline bool operator==(const UObject &other) const { return this==&other; } + inline bool operator!=(const UObject &other) const { return !operator==(other); } // clone() commented out from the base class: // some compilers do not support co-variant return types diff --git a/src/duckdb/extension/icu/third_party/icu/common/unifiedcache.h b/src/duckdb/extension/icu/third_party/icu/common/unifiedcache.h index 5c0bd76f4..d7f5689fb 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/unifiedcache.h +++ b/src/duckdb/extension/icu/third_party/icu/common/unifiedcache.h @@ -56,7 +56,7 @@ class U_COMMON_API CacheKeyBase : public UObject { /** * Equality operator. */ - virtual UBool operator == (const CacheKeyBase &other) const = 0; + virtual bool operator == (const CacheKeyBase &other) const = 0; /** * Create a new object for this key. Called by cache on cache miss. @@ -83,7 +83,7 @@ class U_COMMON_API CacheKeyBase : public UObject { /** * Inequality operator. */ - UBool operator != (const CacheKeyBase &other) const { + bool operator != (const CacheKeyBase &other) const { return !(*this == other); } private: @@ -123,7 +123,7 @@ class CacheKey : public CacheKeyBase { /** * Two objects are equal if they are of the same type. */ - virtual UBool operator == (const CacheKeyBase &other) const { + virtual bool operator == (const CacheKeyBase &other) const { return typeid(*this) == typeid(other); } }; @@ -144,7 +144,7 @@ class LocaleCacheKey : public CacheKey { virtual int32_t hashCode() const { return (int32_t)(37u * (uint32_t)CacheKey::hashCode() + (uint32_t)fLoc.hashCode()); } - virtual UBool operator == (const CacheKeyBase &other) const { + virtual bool operator == (const CacheKeyBase &other) const { // reflexive if (this == &other) { return TRUE; diff --git a/src/duckdb/extension/icu/third_party/icu/common/uniset.cpp b/src/duckdb/extension/icu/third_party/icu/common/uniset.cpp index 1936fedb6..92545c74e 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/uniset.cpp +++ b/src/duckdb/extension/icu/third_party/icu/common/uniset.cpp @@ -300,7 +300,7 @@ UnicodeSet *UnicodeSet::cloneAsThawed() const { * @param o set to be compared for equality with this set. * @return true if the specified set is equal to this set. */ -UBool UnicodeSet::operator==(const UnicodeSet& o) const { +bool UnicodeSet::operator==(const UnicodeSet& o) const { if (len != o.len) return FALSE; for (int32_t i = 0; i < len; ++i) { if (list[i] != o.list[i]) return FALSE; diff --git a/src/duckdb/extension/icu/third_party/icu/common/ustr_titlecase_brkiter.cpp b/src/duckdb/extension/icu/third_party/icu/common/ustr_titlecase_brkiter.cpp index 4b6120294..8f4b956fc 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/ustr_titlecase_brkiter.cpp +++ b/src/duckdb/extension/icu/third_party/icu/common/ustr_titlecase_brkiter.cpp @@ -44,7 +44,7 @@ // public: // WholeStringBreakIterator() : BreakIterator(), length(0) {} // ~WholeStringBreakIterator() U_OVERRIDE; -// UBool operator==(const BreakIterator&) const U_OVERRIDE; +// bool operator==(const BreakIterator&) const U_OVERRIDE; // WholeStringBreakIterator *clone() const U_OVERRIDE; // static UClassID U_EXPORT2 getStaticClassID(); // UClassID getDynamicClassID() const U_OVERRIDE; diff --git a/src/duckdb/extension/icu/third_party/icu/common/ustrenum.cpp b/src/duckdb/extension/icu/third_party/icu/common/ustrenum.cpp index 9396cea73..0d11fdd81 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/ustrenum.cpp +++ b/src/duckdb/extension/icu/third_party/icu/common/ustrenum.cpp @@ -120,12 +120,12 @@ StringEnumeration::setChars(const char *s, int32_t length, UErrorCode &status) { return NULL; } -UBool +bool StringEnumeration::operator==(const StringEnumeration& that)const { return typeid(*this) == typeid(that); } -UBool +bool StringEnumeration::operator!=(const StringEnumeration& that)const { return !operator==(that); } diff --git a/src/duckdb/extension/icu/third_party/icu/common/uvector.cpp b/src/duckdb/extension/icu/third_party/icu/common/uvector.cpp index cb5b6b984..e91cea72c 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/uvector.cpp +++ b/src/duckdb/extension/icu/third_party/icu/common/uvector.cpp @@ -110,7 +110,7 @@ void UVector::assign(const UVector& other, UElementAssigner *assign, UErrorCode } // This only does something sensible if this object has a non-null comparer -UBool UVector::operator==(const UVector& other) { +bool UVector::operator==(const UVector& other) { int32_t i; if (count != other.count) return FALSE; if (comparer != NULL) { diff --git a/src/duckdb/extension/icu/third_party/icu/common/uvector.h b/src/duckdb/extension/icu/third_party/icu/common/uvector.h index 98318d14c..01403cc2a 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/uvector.h +++ b/src/duckdb/extension/icu/third_party/icu/common/uvector.h @@ -113,12 +113,12 @@ class U_COMMON_API UVector : public UObject { * equal if they are of the same size and all elements are equal, * as compared using this object's comparer. */ - UBool operator==(const UVector& other); + bool operator==(const UVector& other); /** * Equivalent to !operator==() */ - inline UBool operator!=(const UVector& other); + inline bool operator!=(const UVector& other); //------------------------------------------------------------ // java.util.Vector API @@ -382,7 +382,7 @@ inline void* UVector::operator[](int32_t index) const { return elementAt(index); } -inline UBool UVector::operator!=(const UVector& other) { +inline bool UVector::operator!=(const UVector& other) { return !operator==(other); } diff --git a/src/duckdb/extension/icu/third_party/icu/common/uvectr32.cpp b/src/duckdb/extension/icu/third_party/icu/common/uvectr32.cpp index ce4542c4b..571d92bd0 100644 --- a/src/duckdb/extension/icu/third_party/icu/common/uvectr32.cpp +++ b/src/duckdb/extension/icu/third_party/icu/common/uvectr32.cpp @@ -83,7 +83,7 @@ void UVector32::assign(const UVector32& other, UErrorCode &ec) { } -UBool UVector32::operator==(const UVector32& other) { +bool UVector32::operator==(const UVector32& other) { int32_t i; if (count != other.count) return FALSE; for (i=0; i::hashCode() + (uint32_t)fSkeleton.hashCode()); } - virtual UBool operator==(const CacheKeyBase &other) const { + virtual bool operator==(const CacheKeyBase &other) const { // reflexive if (this == &other) { return TRUE; @@ -174,7 +174,7 @@ DateFormat::~DateFormat() //---------------------------------------------------------------------- -UBool +bool DateFormat::operator==(const Format& other) const { // This protected comparison operator should only be called by subclasses diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/dcfmtsym.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/dcfmtsym.cpp index e6bafa4b3..6035c0091 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/dcfmtsym.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/dcfmtsym.cpp @@ -173,7 +173,7 @@ DecimalFormatSymbols::operator=(const DecimalFormatSymbols& rhs) // ------------------------------------- -UBool +bool DecimalFormatSymbols::operator==(const DecimalFormatSymbols& that) const { if (this == &that) { diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/decimfmt.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/decimfmt.cpp index 7ce1ef560..007185446 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/decimfmt.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/decimfmt.cpp @@ -500,7 +500,7 @@ DecimalFormat* DecimalFormat::clone() const { return nullptr; } -UBool DecimalFormat::operator==(const Format& other) const { +bool DecimalFormat::operator==(const Format& other) const { auto* otherDF = dynamic_cast(&other); if (otherDF == nullptr) { return false; diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/dtfmtsym.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/dtfmtsym.cpp index 67eb89270..b9ab31caa 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/dtfmtsym.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/dtfmtsym.cpp @@ -534,7 +534,7 @@ DateFormatSymbols::arrayCompare(const UnicodeString* array1, return TRUE; } -UBool +bool DateFormatSymbols::operator==(const DateFormatSymbols& other) const { // First do cheap comparisons diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/dtitvfmt.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/dtitvfmt.cpp index 4d330f0c2..810348ad0 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/dtitvfmt.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/dtitvfmt.cpp @@ -221,7 +221,7 @@ DateIntervalFormat::clone() const { } -UBool +bool DateIntervalFormat::operator==(const Format& other) const { if (typeid(*this) != typeid(other)) {return FALSE;} const DateIntervalFormat* fmt = (DateIntervalFormat*)&other; diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/dtitvinf.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/dtitvinf.cpp index 9356c8550..eb15ef650 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/dtitvinf.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/dtitvinf.cpp @@ -165,7 +165,7 @@ DateIntervalInfo::~DateIntervalInfo() { } -UBool +bool DateIntervalInfo::operator==(const DateIntervalInfo& other) const { UBool equal = ( fFallbackIntervalPattern == other.fFallbackIntervalPattern && diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/dtptngen.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/dtptngen.cpp index 4063422a7..2f6d90bed 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/dtptngen.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/dtptngen.cpp @@ -411,7 +411,7 @@ DateTimePatternGenerator::operator=(const DateTimePatternGenerator& other) { } -UBool +bool DateTimePatternGenerator::operator==(const DateTimePatternGenerator& other) const { if (this == &other) { return TRUE; @@ -435,7 +435,7 @@ DateTimePatternGenerator::operator==(const DateTimePatternGenerator& other) cons } } -UBool +bool DateTimePatternGenerator::operator!=(const DateTimePatternGenerator& other) const { return !operator==(other); } diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/dtptngen_impl.h b/src/duckdb/extension/icu/third_party/icu/i18n/dtptngen_impl.h index e489567a7..d6eeac09e 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/dtptngen_impl.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/dtptngen_impl.h @@ -134,20 +134,20 @@ class SkeletonFields : public UMemory { UnicodeString& appendTo(UnicodeString& string) const; UnicodeString& appendFieldTo(int32_t field, UnicodeString& string) const; UChar getFirstChar() const; - inline UBool operator==(const SkeletonFields& other) const; - inline UBool operator!=(const SkeletonFields& other) const; + inline bool operator==(const SkeletonFields& other) const; + inline bool operator!=(const SkeletonFields& other) const; private: int8_t chars[UDATPG_FIELD_COUNT]; int8_t lengths[UDATPG_FIELD_COUNT]; }; -inline UBool SkeletonFields::operator==(const SkeletonFields& other) const { +inline bool SkeletonFields::operator==(const SkeletonFields& other) const { return (uprv_memcmp(chars, other.chars, sizeof(chars)) == 0 && uprv_memcmp(lengths, other.lengths, sizeof(lengths)) == 0); } -inline UBool SkeletonFields::operator!=(const SkeletonFields& other) const { +inline bool SkeletonFields::operator!=(const SkeletonFields& other) const { return (! operator==(other)); } diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/dtrule.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/dtrule.cpp index 6847f1d16..63949b63a 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/dtrule.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/dtrule.cpp @@ -81,7 +81,7 @@ DateTimeRule::operator=(const DateTimeRule& right) { return *this; } -UBool +bool DateTimeRule::operator==(const DateTimeRule& that) const { return ((this == &that) || (typeid(*this) == typeid(that) && @@ -94,7 +94,7 @@ DateTimeRule::operator==(const DateTimeRule& that) const { fTimeRuleType == that.fTimeRuleType)); } -UBool +bool DateTimeRule::operator!=(const DateTimeRule& that) const { return !operator==(that); } diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/fmtable.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/fmtable.cpp index 6bcb5d190..f5d94cd44 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/fmtable.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/fmtable.cpp @@ -275,7 +275,7 @@ Formattable::operator=(const Formattable& source) // ------------------------------------- -UBool +bool Formattable::operator==(const Formattable& that) const { int32_t i; diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/format.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/format.cpp index 7139af847..fe4bfcda0 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/format.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/format.cpp @@ -151,7 +151,7 @@ Format::parseObject(const UnicodeString& source, // ------------------------------------- -UBool +bool Format::operator==(const Format& that) const { // Subclasses: Call this method and then add more specific checks. diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/fpositer.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/fpositer.cpp index 75d529eb8..2db774927 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/fpositer.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/fpositer.cpp @@ -45,7 +45,7 @@ FieldPositionIterator::FieldPositionIterator(const FieldPositionIterator &rhs) } } -UBool FieldPositionIterator::operator==(const FieldPositionIterator &rhs) const { +bool FieldPositionIterator::operator==(const FieldPositionIterator &rhs) const { if (&rhs == this) { return TRUE; } diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/measfmt.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/measfmt.cpp index 1949f17b1..2783807bc 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/measfmt.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/measfmt.cpp @@ -424,7 +424,7 @@ MeasureFormat::~MeasureFormat() { delete listFormatter; } -UBool MeasureFormat::operator==(const Format &other) const { +bool MeasureFormat::operator==(const Format &other) const { if (this == &other) { // Same object, equal return TRUE; } diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/measunit.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/measunit.cpp index 7a0a60605..17d8c0ec0 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/measunit.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/measunit.cpp @@ -2042,7 +2042,7 @@ const char *MeasureUnit::getSubtype() const { return fCurrency[0] == 0 ? gSubTypes[getOffset()] : fCurrency; } -UBool MeasureUnit::operator==(const UObject& other) const { +bool MeasureUnit::operator==(const UObject& other) const { if (this == &other) { // Same object, equal return TRUE; } diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/measure.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/measure.cpp index bffa44215..cf8e3568a 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/measure.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/measure.cpp @@ -56,7 +56,7 @@ Measure::~Measure() { delete unit; } -UBool Measure::operator==(const UObject& other) const { +bool Measure::operator==(const UObject& other) const { if (this == &other) { // Same object, equal return TRUE; } diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/msgfmt.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/msgfmt.cpp index b97dcfa1d..b187a0078 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/msgfmt.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/msgfmt.cpp @@ -389,7 +389,7 @@ MessageFormat::operator=(const MessageFormat& that) return *this; } -UBool +bool MessageFormat::operator==(const Format& rhs) const { if (this == &rhs) return TRUE; @@ -1869,7 +1869,7 @@ UBool MessageFormat::equalFormats(const void* left, const void* right) { } -UBool MessageFormat::DummyFormat::operator==(const Format&) const { +bool MessageFormat::DummyFormat::operator==(const Format&) const { return TRUE; } diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/nfrs.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/nfrs.cpp index d4e7d2058..dc337728f 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/nfrs.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/nfrs.cpp @@ -344,7 +344,7 @@ util_equalRules(const NFRule* rule1, const NFRule* rule2) return FALSE; } -UBool +bool NFRuleSet::operator==(const NFRuleSet& rhs) const { if (rules.size() == rhs.rules.size() && diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/nfrs.h b/src/duckdb/extension/icu/third_party/icu/i18n/nfrs.h index db03c9039..1c3bf4219 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/nfrs.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/nfrs.h @@ -40,8 +40,8 @@ class NFRuleSet : public UMemory { ~NFRuleSet(); - UBool operator==(const NFRuleSet& rhs) const; - UBool operator!=(const NFRuleSet& rhs) const { return !operator==(rhs); } + bool operator==(const NFRuleSet& rhs) const; + bool operator!=(const NFRuleSet& rhs) const { return !operator==(rhs); } UBool isPublic() const { return fIsPublic; } diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/nfrule.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/nfrule.cpp index 487354565..b1c83121a 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/nfrule.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/nfrule.cpp @@ -631,7 +631,7 @@ util_equalSubstitutions(const NFSubstitution* sub1, const NFSubstitution* sub2) * @param that The rule to compare this one against * @return True is the two rules are functionally equivalent */ -UBool +bool NFRule::operator==(const NFRule& rhs) const { return baseValue == rhs.baseValue diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/nfrule.h b/src/duckdb/extension/icu/third_party/icu/i18n/nfrule.h index ed33eaa5a..0934b5490 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/nfrule.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/nfrule.h @@ -54,8 +54,8 @@ class NFRule : public UMemory { NFRule(const RuleBasedNumberFormat* rbnf, const UnicodeString &ruleText, UErrorCode &status); ~NFRule(); - UBool operator==(const NFRule& rhs) const; - UBool operator!=(const NFRule& rhs) const { return !operator==(rhs); } + bool operator==(const NFRule& rhs) const; + bool operator!=(const NFRule& rhs) const { return !operator==(rhs); } ERuleType getType() const { return (ERuleType)(baseValue <= kNoBase ? (ERuleType)baseValue : kOtherRule); } void setType(ERuleType ruleType) { baseValue = (int32_t)ruleType; } diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/nfsubs.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/nfsubs.cpp index 8ef8e00e5..77e49af87 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/nfsubs.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/nfsubs.cpp @@ -96,7 +96,7 @@ class MultiplierSubstitution : public NFSubstitution { } } - virtual UBool operator==(const NFSubstitution& rhs) const; + virtual bool operator==(const NFSubstitution& rhs) const; virtual int64_t transformNumber(int64_t number) const { return number / divisor; @@ -145,7 +145,7 @@ class ModulusSubstitution : public NFSubstitution { } } - virtual UBool operator==(const NFSubstitution& rhs) const; + virtual bool operator==(const NFSubstitution& rhs) const; virtual void doSubstitution(int64_t number, UnicodeString& toInsertInto, int32_t pos, int32_t recursionCount, UErrorCode& status) const; virtual void doSubstitution(double number, UnicodeString& toInsertInto, int32_t pos, int32_t recursionCount, UErrorCode& status) const; @@ -213,7 +213,7 @@ class FractionalPartSubstitution : public NFSubstitution { UErrorCode& status); virtual ~FractionalPartSubstitution(); - virtual UBool operator==(const NFSubstitution& rhs) const; + virtual bool operator==(const NFSubstitution& rhs) const; virtual void doSubstitution(double number, UnicodeString& toInsertInto, int32_t pos, int32_t recursionCount, UErrorCode& status) const; virtual void doSubstitution(int64_t /*number*/, UnicodeString& /*toInsertInto*/, int32_t /*_pos*/, int32_t /*recursionCount*/, UErrorCode& /*status*/) const {} @@ -285,7 +285,7 @@ class NumeratorSubstitution : public NFSubstitution { } virtual ~NumeratorSubstitution(); - virtual UBool operator==(const NFSubstitution& rhs) const; + virtual bool operator==(const NFSubstitution& rhs) const; virtual int64_t transformNumber(int64_t number) const { return number * ldenominator; } virtual double transformNumber(double number) const { return uprv_round(number * denominator); } @@ -515,7 +515,7 @@ UOBJECT_DEFINE_RTTI_IMPLEMENTATION(NFSubstitution) * @param The substitution to compare this one to * @return true if the two substitutions are functionally equivalent */ -UBool +bool NFSubstitution::operator==(const NFSubstitution& rhs) const { // compare class and all of the fields all substitutions have @@ -810,7 +810,7 @@ UOBJECT_DEFINE_RTTI_IMPLEMENTATION(SameValueSubstitution) UOBJECT_DEFINE_RTTI_IMPLEMENTATION(MultiplierSubstitution) -UBool MultiplierSubstitution::operator==(const NFSubstitution& rhs) const +bool MultiplierSubstitution::operator==(const NFSubstitution& rhs) const { return NFSubstitution::operator==(rhs) && divisor == ((const MultiplierSubstitution*)&rhs)->divisor; @@ -856,7 +856,7 @@ ModulusSubstitution::ModulusSubstitution(int32_t _pos, UOBJECT_DEFINE_RTTI_IMPLEMENTATION(ModulusSubstitution) -UBool ModulusSubstitution::operator==(const NFSubstitution& rhs) const +bool ModulusSubstitution::operator==(const NFSubstitution& rhs) const { return NFSubstitution::operator==(rhs) && divisor == ((const ModulusSubstitution*)&rhs)->divisor && @@ -1195,7 +1195,7 @@ FractionalPartSubstitution::doParse(const UnicodeString& text, } } -UBool +bool FractionalPartSubstitution::operator==(const NFSubstitution& rhs) const { return NFSubstitution::operator==(rhs) && @@ -1325,7 +1325,7 @@ NumeratorSubstitution::doParse(const UnicodeString& text, return TRUE; } -UBool +bool NumeratorSubstitution::operator==(const NFSubstitution& rhs) const { return NFSubstitution::operator==(rhs) && diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/nfsubs.h b/src/duckdb/extension/icu/third_party/icu/i18n/nfsubs.h index 948627c0c..49eb0a070 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/nfsubs.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/nfsubs.h @@ -74,7 +74,7 @@ class NFSubstitution : public UObject { * @param rhs the object to be compared with. * @return true if the given Format objects are semantically equal. */ - virtual UBool operator==(const NFSubstitution& rhs) const; + virtual bool operator==(const NFSubstitution& rhs) const; /** * Return true if the given Format objects are semantically unequal. @@ -82,7 +82,7 @@ class NFSubstitution : public UObject { * @param rhs the object to be compared with. * @return true if the given Format objects are semantically unequal. */ - UBool operator!=(const NFSubstitution& rhs) const { return !operator==(rhs); } + bool operator!=(const NFSubstitution& rhs) const { return !operator==(rhs); } /** * Sets the substitution's divisor. Used by NFRule.setBaseValue(). diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/number_asformat.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/number_asformat.cpp index 065f57028..dee276771 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/number_asformat.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/number_asformat.cpp @@ -35,7 +35,7 @@ LocalizedNumberFormatterAsFormat::LocalizedNumberFormatterAsFormat( LocalizedNumberFormatterAsFormat::~LocalizedNumberFormatterAsFormat() = default; -UBool LocalizedNumberFormatterAsFormat::operator==(const Format& other) const { +bool LocalizedNumberFormatterAsFormat::operator==(const Format& other) const { auto* _other = dynamic_cast(&other); if (_other == nullptr) { return false; diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/number_asformat.h b/src/duckdb/extension/icu/third_party/icu/i18n/number_asformat.h index 7b0a1dee6..ca162ae2a 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/number_asformat.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/number_asformat.h @@ -40,7 +40,7 @@ class U_I18N_API LocalizedNumberFormatterAsFormat : public Format { /** * Equals operator. */ - UBool operator==(const Format& other) const U_OVERRIDE; + bool operator==(const Format& other) const U_OVERRIDE; /** * Creates a copy of this object. diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/numfmt.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/numfmt.cpp index 7c3a0551c..a8b55be4b 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/numfmt.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/numfmt.cpp @@ -285,7 +285,7 @@ NumberFormat::operator=(const NumberFormat& rhs) // ------------------------------------- -UBool +bool NumberFormat::operator==(const Format& that) const { // Format::operator== guarantees this cast is safe diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/olsontz.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/olsontz.cpp index d21e6e992..01b913ab7 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/olsontz.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/olsontz.cpp @@ -308,7 +308,7 @@ OlsonTimeZone::~OlsonTimeZone() { /** * Returns true if the two TimeZone objects are equal. */ -UBool OlsonTimeZone::operator==(const TimeZone& other) const { +bool OlsonTimeZone::operator==(const TimeZone& other) const { return ((this == &other) || (typeid(*this) == typeid(other) && TimeZone::operator==(other) && diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/olsontz.h b/src/duckdb/extension/icu/third_party/icu/i18n/olsontz.h index a3b7dcc8f..c4e225910 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/olsontz.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/olsontz.h @@ -146,7 +146,7 @@ class U_I18N_API OlsonTimeZone: public BasicTimeZone { /** * Returns true if the two TimeZone objects are equal. */ - virtual UBool operator==(const TimeZone& other) const; + virtual bool operator==(const TimeZone& other) const; /** * TimeZone API. diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/plurfmt.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/plurfmt.cpp index b99437630..292a3168a 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/plurfmt.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/plurfmt.cpp @@ -381,7 +381,7 @@ PluralFormat::operator=(const PluralFormat& other) { return *this; } -UBool +bool PluralFormat::operator==(const Format& other) const { if (this == &other) { return TRUE; @@ -400,7 +400,7 @@ PluralFormat::operator==(const Format& other) const { *pluralRulesWrapper.pluralRules == *o.pluralRulesWrapper.pluralRules); } -UBool +bool PluralFormat::operator!=(const Format& other) const { return !operator==(other); } diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/plurrule.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/plurrule.cpp index 4bca51720..9c1791a9b 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/plurrule.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/plurrule.cpp @@ -440,7 +440,7 @@ PluralRules::getKeywordOther() const { return UnicodeString(TRUE, PLURAL_KEYWORD_OTHER, 5); } -UBool +bool PluralRules::operator==(const PluralRules& other) const { const UnicodeString *ptrKeyword; UErrorCode status= U_ZERO_ERROR; diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/rbnf.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/rbnf.cpp index 49e6bf9e9..0efc2ddce 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/rbnf.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/rbnf.cpp @@ -99,8 +99,8 @@ class LocalizationInfo : public UMemory { return NULL; } - virtual UBool operator==(const LocalizationInfo* rhs) const; - inline UBool operator!=(const LocalizationInfo* rhs) const { return !operator==(rhs); } + virtual bool operator==(const LocalizationInfo* rhs) const; + inline bool operator!=(const LocalizationInfo* rhs) const { return !operator==(rhs); } virtual int32_t getNumberOfRuleSets(void) const = 0; virtual const UChar* getRuleSetName(int32_t index) const = 0; @@ -131,7 +131,7 @@ streq(const UChar* lhs, const UChar* rhs) { return FALSE; } -UBool +bool LocalizationInfo::operator==(const LocalizationInfo* rhs) const { if (rhs) { if (this == rhs) { @@ -936,7 +936,7 @@ RuleBasedNumberFormat::clone() const return new RuleBasedNumberFormat(*this); } -UBool +bool RuleBasedNumberFormat::operator==(const Format& other) const { if (this == &other) { diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/rbtz.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/rbtz.cpp index 3249a32a1..7cf1d37e5 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/rbtz.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/rbtz.cpp @@ -88,7 +88,7 @@ RuleBasedTimeZone::operator=(const RuleBasedTimeZone& right) { return *this; } -UBool +bool RuleBasedTimeZone::operator==(const TimeZone& that) const { if (this == &that) { return TRUE; @@ -108,7 +108,7 @@ RuleBasedTimeZone::operator==(const TimeZone& that) const { return FALSE; } -UBool +bool RuleBasedTimeZone::operator!=(const TimeZone& that) const { return !operator==(that); } diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/region.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/region.cpp index 76445aef3..0d9e7a1b7 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/region.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/region.cpp @@ -439,7 +439,7 @@ Region::~Region () { * Returns true if the two regions are equal. * Per PMC, just use pointer compare, since we have at most one instance of each Region. */ -UBool +bool Region::operator==(const Region &that) const { return (idStr == that.idStr); } @@ -448,7 +448,7 @@ Region::operator==(const Region &that) const { * Returns true if the two regions are NOT equal; that is, if operator ==() returns false. * Per PMC, just use pointer compare, since we have at most one instance of each Region. */ -UBool +bool Region::operator!=(const Region &that) const { return (idStr != that.idStr); } diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/reldtfmt.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/reldtfmt.cpp index af62aaee7..1c8c44a88 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/reldtfmt.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/reldtfmt.cpp @@ -135,7 +135,7 @@ RelativeDateFormat* RelativeDateFormat::clone() const { return new RelativeDateFormat(*this); } -UBool RelativeDateFormat::operator==(const Format& other) const { +bool RelativeDateFormat::operator==(const Format& other) const { if(DateFormat::operator==(other)) { // The DateFormat::operator== check for fCapitalizationContext equality above // is sufficient to check equality of all derived context-related data. diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/reldtfmt.h b/src/duckdb/extension/icu/third_party/icu/i18n/reldtfmt.h index 02760569e..24fffb7b5 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/reldtfmt.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/reldtfmt.h @@ -80,7 +80,7 @@ class RelativeDateFormat : public DateFormat { * @return true if the given Format objects are semantically equal. * @internal ICU 3.8 */ - virtual UBool operator==(const Format& other) const; + virtual bool operator==(const Format& other) const; using DateFormat::format; diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/rulebasedcollator.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/rulebasedcollator.cpp index 60acf1781..f00d536c2 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/rulebasedcollator.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/rulebasedcollator.cpp @@ -239,7 +239,7 @@ RuleBasedCollator &RuleBasedCollator::operator=(const RuleBasedCollator &other) UOBJECT_DEFINE_RTTI_IMPLEMENTATION(RuleBasedCollator) -UBool +bool RuleBasedCollator::operator==(const Collator& other) const { if(this == &other) { return TRUE; } if(!Collator::operator==(other)) { return FALSE; } diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/selfmt.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/selfmt.cpp index 3badef4fd..37f4e6ed8 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/selfmt.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/selfmt.cpp @@ -164,7 +164,7 @@ SelectFormat::operator=(const SelectFormat& other) { return *this; } -UBool +bool SelectFormat::operator==(const Format& other) const { if (this == &other) { return TRUE; @@ -176,7 +176,7 @@ SelectFormat::operator==(const Format& other) const { return msgPattern == o.msgPattern; } -UBool +bool SelectFormat::operator!=(const Format& other) const { return !operator==(other); } diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/simpletz.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/simpletz.cpp index 7972e2bb0..80e0df555 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/simpletz.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/simpletz.cpp @@ -231,7 +231,7 @@ SimpleTimeZone::operator=(const SimpleTimeZone &right) // ------------------------------------- -UBool +bool SimpleTimeZone::operator==(const TimeZone& that) const { return ((this == &that) || diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/smpdtfmt.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/smpdtfmt.cpp index d16eed035..68792a318 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/smpdtfmt.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/smpdtfmt.cpp @@ -628,7 +628,7 @@ SimpleDateFormat::clone() const //---------------------------------------------------------------------- -UBool +bool SimpleDateFormat::operator==(const Format& other) const { if (DateFormat::operator==(other)) { diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/sortkey.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/sortkey.cpp index 12289482e..2a86cad1b 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/sortkey.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/sortkey.cpp @@ -137,7 +137,7 @@ CollationKey::setToBogus() return *this; } -UBool +bool CollationKey::operator==(const CollationKey& source) const { return getLength() == source.getLength() && diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/timezone.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/timezone.cpp index 7d0f094a2..e8c670448 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/timezone.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/timezone.cpp @@ -376,7 +376,7 @@ TimeZone::operator=(const TimeZone &right) // ------------------------------------- -UBool +bool TimeZone::operator==(const TimeZone& that) const { return typeid(*this) == typeid(that) && diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/tmutamt.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/tmutamt.cpp index 25464693e..2753c2937 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/tmutamt.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/tmutamt.cpp @@ -45,7 +45,7 @@ TimeUnitAmount::operator=(const TimeUnitAmount& other) { } -UBool +bool TimeUnitAmount::operator==(const UObject& other) const { return Measure::operator==(other); } diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/tzfmt.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/tzfmt.cpp index 0beaa310d..2f4166c93 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/tzfmt.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/tzfmt.cpp @@ -482,7 +482,7 @@ TimeZoneFormat::operator=(const TimeZoneFormat& other) { } -UBool +bool TimeZoneFormat::operator==(const Format& other) const { TimeZoneFormat* tzfmt = (TimeZoneFormat*)&other; diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/tzgnames.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/tzgnames.cpp index b8d44244c..eb4d80103 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/tzgnames.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/tzgnames.cpp @@ -1287,7 +1287,7 @@ TimeZoneGenericNames::createInstance(const Locale& locale, UErrorCode& status) { return instance; } -UBool +bool TimeZoneGenericNames::operator==(const TimeZoneGenericNames& other) const { // Just compare if the other object also use the same // ref entry diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/tzgnames.h b/src/duckdb/extension/icu/third_party/icu/i18n/tzgnames.h index 71d9d84dc..6be9862b1 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/tzgnames.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/tzgnames.h @@ -45,8 +45,8 @@ class U_I18N_API TimeZoneGenericNames : public UMemory { static TimeZoneGenericNames* createInstance(const Locale& locale, UErrorCode& status); - virtual UBool operator==(const TimeZoneGenericNames& other) const; - virtual UBool operator!=(const TimeZoneGenericNames& other) const {return !operator==(other);} + virtual bool operator==(const TimeZoneGenericNames& other) const; + virtual bool operator!=(const TimeZoneGenericNames& other) const {return !operator==(other);} virtual TimeZoneGenericNames* clone() const; UnicodeString& getDisplayName(const TimeZone& tz, UTimeZoneGenericNameType type, diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/tznames.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/tznames.cpp index 2343c9a26..d898bc2e8 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/tznames.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/tznames.cpp @@ -104,8 +104,8 @@ class TimeZoneNamesDelegate : public TimeZoneNames { TimeZoneNamesDelegate(const Locale& locale, UErrorCode& status); virtual ~TimeZoneNamesDelegate(); - virtual UBool operator==(const TimeZoneNames& other) const; - virtual UBool operator!=(const TimeZoneNames& other) const {return !operator==(other);} + virtual bool operator==(const TimeZoneNames& other) const; + virtual bool operator!=(const TimeZoneNames& other) const {return !operator==(other);} virtual TimeZoneNamesDelegate* clone() const; StringEnumeration* getAvailableMetaZoneIDs(UErrorCode& status) const; @@ -219,7 +219,7 @@ TimeZoneNamesDelegate::~TimeZoneNamesDelegate() { umtx_unlock(&gTimeZoneNamesLock); } -UBool +bool TimeZoneNamesDelegate::operator==(const TimeZoneNames& other) const { if (this == &other) { return TRUE; diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/tznames_impl.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/tznames_impl.cpp index 43cf8f430..14c8e8d71 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/tznames_impl.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/tznames_impl.cpp @@ -1104,7 +1104,7 @@ TimeZoneNamesImpl::cleanup() { } } -UBool +bool TimeZoneNamesImpl::operator==(const TimeZoneNames& other) const { if (this == &other) { return TRUE; @@ -2156,7 +2156,7 @@ TZDBTimeZoneNames::TZDBTimeZoneNames(const Locale& locale) TZDBTimeZoneNames::~TZDBTimeZoneNames() { } -UBool +bool TZDBTimeZoneNames::operator==(const TimeZoneNames& other) const { if (this == &other) { return TRUE; diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/tznames_impl.h b/src/duckdb/extension/icu/third_party/icu/i18n/tznames_impl.h index 1286eeb80..f70452c60 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/tznames_impl.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/tznames_impl.h @@ -173,7 +173,7 @@ class TimeZoneNamesImpl : public TimeZoneNames { virtual ~TimeZoneNamesImpl(); - virtual UBool operator==(const TimeZoneNames& other) const; + virtual bool operator==(const TimeZoneNames& other) const; virtual TimeZoneNamesImpl* clone() const; StringEnumeration* getAvailableMetaZoneIDs(UErrorCode& status) const; @@ -235,7 +235,7 @@ class TZDBTimeZoneNames : public TimeZoneNames { TZDBTimeZoneNames(const Locale& locale); virtual ~TZDBTimeZoneNames(); - virtual UBool operator==(const TimeZoneNames& other) const; + virtual bool operator==(const TimeZoneNames& other) const; virtual TZDBTimeZoneNames* clone() const; StringEnumeration* getAvailableMetaZoneIDs(UErrorCode& status) const; diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/tzrule.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/tzrule.cpp index 759a2d4c6..0303cfcf1 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/tzrule.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/tzrule.cpp @@ -53,7 +53,7 @@ TimeZoneRule::operator=(const TimeZoneRule& right) { return *this; } -UBool +bool TimeZoneRule::operator==(const TimeZoneRule& that) const { return ((this == &that) || (typeid(*this) == typeid(that) && @@ -62,7 +62,7 @@ TimeZoneRule::operator==(const TimeZoneRule& that) const { fDSTSavings == that.fDSTSavings)); } -UBool +bool TimeZoneRule::operator!=(const TimeZoneRule& that) const { return !operator==(that); } @@ -120,14 +120,14 @@ InitialTimeZoneRule::operator=(const InitialTimeZoneRule& right) { return *this; } -UBool +bool InitialTimeZoneRule::operator==(const TimeZoneRule& that) const { return ((this == &that) || (typeid(*this) == typeid(that) && TimeZoneRule::operator==(that))); } -UBool +bool InitialTimeZoneRule::operator!=(const TimeZoneRule& that) const { return !operator==(that); } @@ -226,7 +226,7 @@ AnnualTimeZoneRule::operator=(const AnnualTimeZoneRule& right) { return *this; } -UBool +bool AnnualTimeZoneRule::operator==(const TimeZoneRule& that) const { if (this == &that) { return TRUE; @@ -240,7 +240,7 @@ AnnualTimeZoneRule::operator==(const TimeZoneRule& that) const { fEndYear == atzr->fEndYear); } -UBool +bool AnnualTimeZoneRule::operator!=(const TimeZoneRule& that) const { return !operator==(that); } @@ -445,7 +445,7 @@ TimeArrayTimeZoneRule::operator=(const TimeArrayTimeZoneRule& right) { return *this; } -UBool +bool TimeArrayTimeZoneRule::operator==(const TimeZoneRule& that) const { if (this == &that) { return TRUE; @@ -469,7 +469,7 @@ TimeArrayTimeZoneRule::operator==(const TimeZoneRule& that) const { return res; } -UBool +bool TimeArrayTimeZoneRule::operator!=(const TimeZoneRule& that) const { return !operator==(that); } diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/tztrans.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/tztrans.cpp index 3199b78ea..8230ed209 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/tztrans.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/tztrans.cpp @@ -63,7 +63,7 @@ TimeZoneTransition::operator=(const TimeZoneTransition& right) { return *this; } -UBool +bool TimeZoneTransition::operator==(const TimeZoneTransition& that) const { if (this == &that) { return TRUE; @@ -84,7 +84,7 @@ TimeZoneTransition::operator==(const TimeZoneTransition& that) const { return FALSE; } -UBool +bool TimeZoneTransition::operator!=(const TimeZoneTransition& that) const { return !operator==(that); } diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/alphaindex.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/alphaindex.h index e3c68ea7c..d38a20893 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/alphaindex.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/alphaindex.h @@ -660,13 +660,13 @@ class U_I18N_API AlphabeticIndex: public UObject { * No Equality operators. * @internal */ - virtual UBool operator==(const AlphabeticIndex& other) const; + virtual bool operator==(const AlphabeticIndex& other) const; /** * Inequality operator. * @internal */ - virtual UBool operator!=(const AlphabeticIndex& other) const; + virtual bool operator!=(const AlphabeticIndex& other) const; // Common initialization, for use from all constructors. void init(const Locale *locale, UErrorCode &status); diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/calendar.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/calendar.h index 2a8c2935c..ba880c30d 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/calendar.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/calendar.h @@ -451,7 +451,7 @@ class U_I18N_API Calendar : public UObject { * otherwise. * @stable ICU 2.0 */ - virtual UBool operator==(const Calendar& that) const; + virtual bool operator==(const Calendar& that) const; /** * Compares the inequality of two Calendar objects. @@ -461,7 +461,7 @@ class U_I18N_API Calendar : public UObject { * otherwise. * @stable ICU 2.0 */ - UBool operator!=(const Calendar& that) const {return !operator==(that);} + bool operator!=(const Calendar& that) const {return !operator==(that);} /** * Returns TRUE if the given Calendar object is equivalent to this diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/choicfmt.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/choicfmt.h index 3b2f48cb1..867cd38d0 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/choicfmt.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/choicfmt.h @@ -261,7 +261,7 @@ class U_I18N_API ChoiceFormat: public NumberFormat { * @return true if other is the same as this. * @deprecated ICU 49 Use MessageFormat instead, with plural and select arguments. */ - virtual UBool operator==(const Format& other) const; + virtual bool operator==(const Format& other) const; /** * Sets the pattern. diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/coleitr.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/coleitr.h index f4995e05e..c028aef6b 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/coleitr.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/coleitr.h @@ -156,7 +156,7 @@ class U_I18N_API CollationElementIterator U_FINAL : public UObject { * @return true if "other" is the same as "this" * @stable ICU 2.0 */ - UBool operator==(const CollationElementIterator& other) const; + bool operator==(const CollationElementIterator& other) const; /** * Returns true if "other" is not the same as "this". @@ -165,7 +165,7 @@ class U_I18N_API CollationElementIterator U_FINAL : public UObject { * @return true if "other" is not the same as "this" * @stable ICU 2.0 */ - UBool operator!=(const CollationElementIterator& other) const; + bool operator!=(const CollationElementIterator& other) const; /** * Resets the cursor to the beginning of the string. diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/coll.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/coll.h index bf478853b..7dcd367c5 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/coll.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/coll.h @@ -251,7 +251,7 @@ class U_I18N_API Collator : public UObject { * @return TRUE if other is the same as this. * @stable ICU 2.0 */ - virtual UBool operator==(const Collator& other) const; + virtual bool operator==(const Collator& other) const; /** * Returns true if "other" is not the same as "this". @@ -260,7 +260,7 @@ class U_I18N_API Collator : public UObject { * @return TRUE if other is not the same as this. * @stable ICU 2.0 */ - virtual UBool operator!=(const Collator& other) const; + virtual bool operator!=(const Collator& other) const; /** * Makes a copy of this object. diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/currpinf.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/currpinf.h index fb0b2a7db..8e73f9f00 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/currpinf.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/currpinf.h @@ -92,7 +92,7 @@ class U_I18N_API CurrencyPluralInfo : public UObject { * * @stable ICU 4.2 */ - UBool operator==(const CurrencyPluralInfo& info) const; + bool operator==(const CurrencyPluralInfo& info) const; /** @@ -100,7 +100,7 @@ class U_I18N_API CurrencyPluralInfo : public UObject { * * @stable ICU 4.2 */ - UBool operator!=(const CurrencyPluralInfo& info) const; + bool operator!=(const CurrencyPluralInfo& info) const; /** @@ -259,7 +259,7 @@ class U_I18N_API CurrencyPluralInfo : public UObject { }; -inline UBool +inline bool CurrencyPluralInfo::operator!=(const CurrencyPluralInfo& info) const { return !operator==(info); } diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/datefmt.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/datefmt.h index b4a6cb302..7ae2fc232 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/datefmt.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/datefmt.h @@ -235,7 +235,7 @@ class U_I18N_API DateFormat : public Format { * Equality operator. Returns true if the two formats have the same behavior. * @stable ICU 2.0 */ - virtual UBool operator==(const Format&) const; + virtual bool operator==(const Format&) const; using Format::format; diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/dcfmtsym.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/dcfmtsym.h index e1e0ab6b0..84f6e07f7 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/dcfmtsym.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/dcfmtsym.h @@ -255,7 +255,7 @@ class U_I18N_API DecimalFormatSymbols : public UObject { * @return true if another object is semantically equal to this one. * @stable ICU 2.0 */ - UBool operator==(const DecimalFormatSymbols& other) const; + bool operator==(const DecimalFormatSymbols& other) const; /** * Return true if another object is semantically unequal to this one. @@ -264,7 +264,7 @@ class U_I18N_API DecimalFormatSymbols : public UObject { * @return true if another object is semantically unequal to this one. * @stable ICU 2.0 */ - UBool operator!=(const DecimalFormatSymbols& other) const { return !operator==(other); } + bool operator!=(const DecimalFormatSymbols& other) const { return !operator==(other); } /** * Get one of the format symbols by its enum constant. diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/decimfmt.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/decimfmt.h index c33ec80ca..d7a12e5e2 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/decimfmt.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/decimfmt.h @@ -909,7 +909,7 @@ class U_I18N_API DecimalFormat : public NumberFormat { * @return true if the given Format objects are semantically equal. * @stable ICU 2.0 */ - UBool operator==(const Format& other) const U_OVERRIDE; + bool operator==(const Format& other) const U_OVERRIDE; using NumberFormat::format; diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/dtfmtsym.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/dtfmtsym.h index c6d76fe98..1bbd92e57 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/dtfmtsym.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/dtfmtsym.h @@ -174,7 +174,7 @@ class U_I18N_API DateFormatSymbols U_FINAL : public UObject { * @return true if other is semantically equal to this. * @stable ICU 2.0 */ - UBool operator==(const DateFormatSymbols& other) const; + bool operator==(const DateFormatSymbols& other) const; /** * Return true if another object is semantically unequal to this one. @@ -183,7 +183,7 @@ class U_I18N_API DateFormatSymbols U_FINAL : public UObject { * @return true if other is semantically unequal to this. * @stable ICU 2.0 */ - UBool operator!=(const DateFormatSymbols& other) const { return !operator==(other); } + bool operator!=(const DateFormatSymbols& other) const { return !operator==(other); } /** * Gets abbreviated era strings. For example: "AD" and "BC". diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/dtitvfmt.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/dtitvfmt.h index 23fc02e2a..e3aea2521 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/dtitvfmt.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/dtitvfmt.h @@ -443,7 +443,7 @@ class U_I18N_API DateIntervalFormat : public Format { * @return true if the given Format objects are semantically equal. * @stable ICU 4.0 */ - virtual UBool operator==(const Format& other) const; + virtual bool operator==(const Format& other) const; /** * Return true if the given Format objects are not semantically equal. @@ -452,7 +452,7 @@ class U_I18N_API DateIntervalFormat : public Format { * @return true if the given Format objects are not semantically equal. * @stable ICU 4.0 */ - UBool operator!=(const Format& other) const; + bool operator!=(const Format& other) const; using Format::format; @@ -1144,7 +1144,7 @@ class U_I18N_API DateIntervalFormat : public Format { UnicodeString* fDateTimeFormat; }; -inline UBool +inline bool DateIntervalFormat::operator!=(const Format& other) const { return !operator==(other); } diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/dtitvinf.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/dtitvinf.h index a894d12ca..f3a6dd01b 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/dtitvinf.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/dtitvinf.h @@ -214,7 +214,7 @@ class U_I18N_API DateIntervalInfo U_FINAL : public UObject { * @return true if other is semantically equal to this. * @stable ICU 4.0 */ - virtual UBool operator==(const DateIntervalInfo& other) const; + virtual bool operator==(const DateIntervalInfo& other) const; /** * Return true if another object is semantically unequal to this one. @@ -223,7 +223,7 @@ class U_I18N_API DateIntervalInfo U_FINAL : public UObject { * @return true if other is semantically unequal to this. * @stable ICU 4.0 */ - UBool operator!=(const DateIntervalInfo& other) const; + bool operator!=(const DateIntervalInfo& other) const; @@ -507,7 +507,7 @@ class U_I18N_API DateIntervalInfo U_FINAL : public UObject { };// end class DateIntervalInfo -inline UBool +inline bool DateIntervalInfo::operator!=(const DateIntervalInfo& other) const { return !operator==(other); } diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/dtptngen.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/dtptngen.h index a71938b31..06bf15702 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/dtptngen.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/dtptngen.h @@ -113,7 +113,7 @@ class U_I18N_API DateTimePatternGenerator : public UObject { * @return true if other is semantically equal to this. * @stable ICU 3.8 */ - UBool operator==(const DateTimePatternGenerator& other) const; + bool operator==(const DateTimePatternGenerator& other) const; /** * Return true if another object is semantically unequal to this one. @@ -122,7 +122,7 @@ class U_I18N_API DateTimePatternGenerator : public UObject { * @return true if other is semantically unequal to this. * @stable ICU 3.8 */ - UBool operator!=(const DateTimePatternGenerator& other) const; + bool operator!=(const DateTimePatternGenerator& other) const; /** * Utility to return a unique skeleton from a given pattern. For example, diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/dtrule.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/dtrule.h index adab8967f..09eeba674 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/dtrule.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/dtrule.h @@ -144,7 +144,7 @@ class U_I18N_API DateTimeRule : public UObject { * @return true if the given DateTimeRule objects are semantically equal. * @stable ICU 3.8 */ - UBool operator==(const DateTimeRule& that) const; + bool operator==(const DateTimeRule& that) const; /** * Return true if the given DateTimeRule objects are semantically unequal. Objects @@ -153,7 +153,7 @@ class U_I18N_API DateTimeRule : public UObject { * @return true if the given DateTimeRule objects are semantically unequal. * @stable ICU 3.8 */ - UBool operator!=(const DateTimeRule& that) const; + bool operator!=(const DateTimeRule& that) const; /** * Gets the date rule type, such as DOM diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/fieldpos.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/fieldpos.h index 23ee38624..4843e0214 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/fieldpos.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/fieldpos.h @@ -164,7 +164,7 @@ class U_I18N_API FieldPosition : public UObject { * @return TRUE if the two field positions are equal, FALSE otherwise. * @stable ICU 2.0 */ - UBool operator==(const FieldPosition& that) const; + bool operator==(const FieldPosition& that) const; /** * Equality operator. @@ -172,7 +172,7 @@ class U_I18N_API FieldPosition : public UObject { * @return TRUE if the two field positions are not equal, FALSE otherwise. * @stable ICU 2.0 */ - UBool operator!=(const FieldPosition& that) const; + bool operator!=(const FieldPosition& that) const; /** * Clone this object. @@ -274,7 +274,7 @@ FieldPosition::operator=(const FieldPosition& copy) return *this; } -inline UBool +inline bool FieldPosition::operator==(const FieldPosition& copy) const { return (fField == copy.fField && @@ -282,7 +282,7 @@ FieldPosition::operator==(const FieldPosition& copy) const fBeginIndex == copy.fBeginIndex); } -inline UBool +inline bool FieldPosition::operator!=(const FieldPosition& copy) const { return !operator==(copy); diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/fmtable.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/fmtable.h index 7bec4f690..a83d905a6 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/fmtable.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/fmtable.h @@ -182,7 +182,7 @@ class U_I18N_API Formattable : public UObject { * @return TRUE if other are equal to this, FALSE otherwise. * @stable ICU 2.0 */ - UBool operator==(const Formattable &other) const; + bool operator==(const Formattable &other) const; /** * Equality operator. @@ -190,7 +190,7 @@ class U_I18N_API Formattable : public UObject { * @return TRUE if other are unequal to this, FALSE otherwise. * @stable ICU 2.0 */ - UBool operator!=(const Formattable& other) const + bool operator!=(const Formattable& other) const { return !operator==(other); } /** diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/format.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/format.h index 8788f77ee..f1a49d958 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/format.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/format.h @@ -111,7 +111,7 @@ class U_I18N_API Format : public UObject { * Objects of different subclasses are considered unequal. * @stable ICU 2.0 */ - virtual UBool operator==(const Format& other) const = 0; + virtual bool operator==(const Format& other) const = 0; /** * Return true if the given Format objects are not semantically @@ -120,7 +120,7 @@ class U_I18N_API Format : public UObject { * @return Return true if the given Format objects are not semantically. * @stable ICU 2.0 */ - UBool operator!=(const Format& other) const { return !operator==(other); } + bool operator!=(const Format& other) const { return !operator==(other); } /** * Clone this object polymorphically. The caller is responsible diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/fpositer.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/fpositer.h index 3e8a0108f..99d691332 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/fpositer.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/fpositer.h @@ -84,7 +84,7 @@ class U_I18N_API FieldPositionIterator : public UObject { * equal array of run values. * @stable ICU 4.4 */ - UBool operator==(const FieldPositionIterator&) const; + bool operator==(const FieldPositionIterator&) const; /** * Returns the complement of the result of operator== @@ -92,7 +92,7 @@ class U_I18N_API FieldPositionIterator : public UObject { * @return the complement of the result of operator== * @stable ICU 4.4 */ - UBool operator!=(const FieldPositionIterator& rhs) const { return !operator==(rhs); } + bool operator!=(const FieldPositionIterator& rhs) const { return !operator==(rhs); } /** * If the current position is valid, updates the FieldPosition values, advances the iterator, diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/measfmt.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/measfmt.h index b4f904862..b7756cb25 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/measfmt.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/measfmt.h @@ -147,7 +147,7 @@ class U_I18N_API MeasureFormat : public Format { * Return true if given Format objects are semantically equal. * @stable ICU 53 */ - virtual UBool operator==(const Format &other) const; + virtual bool operator==(const Format &other) const; /** * Clones this object polymorphically. diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/measunit.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/measunit.h index dbcad62f2..5049c212a 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/measunit.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/measunit.h @@ -77,14 +77,14 @@ class U_I18N_API MeasureUnit: public UObject { * to the given object. * @stable ICU 3.0 */ - virtual UBool operator==(const UObject& other) const; + virtual bool operator==(const UObject& other) const; /** * Inequality operator. Return true if this object is not equal * to the given object. * @stable ICU 53 */ - UBool operator!=(const UObject& other) const { + bool operator!=(const UObject& other) const { return !(*this == other); } diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/measure.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/measure.h index fa9c29351..1fd20dfca 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/measure.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/measure.h @@ -87,7 +87,7 @@ class U_I18N_API Measure: public UObject { * to the given object. * @stable ICU 3.0 */ - UBool operator==(const UObject& other) const; + bool operator==(const UObject& other) const; /** * Return a reference to the numeric value of this object. The diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/msgfmt.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/msgfmt.h index 99b0eaeec..39d70ce04 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/msgfmt.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/msgfmt.h @@ -429,7 +429,7 @@ class U_I18N_API MessageFormat : public Format { * @return true if the given Format objects are semantically equal. * @stable ICU 2.0 */ - virtual UBool operator==(const Format& other) const; + virtual bool operator==(const Format& other) const; /** * Sets the locale to be used for creating argument Format objects. @@ -1088,7 +1088,7 @@ class U_I18N_API MessageFormat : public Format { */ class U_I18N_API DummyFormat : public Format { public: - virtual UBool operator==(const Format&) const; + virtual bool operator==(const Format&) const; virtual DummyFormat* clone() const; virtual UnicodeString& format(const Formattable& obj, UnicodeString& appendTo, diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/numfmt.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/numfmt.h index fbd4fb4e5..af67223bf 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/numfmt.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/numfmt.h @@ -276,7 +276,7 @@ class U_I18N_API NumberFormat : public Format { * @return true if the given Format objects are semantically equal. * @stable ICU 2.0 */ - virtual UBool operator==(const Format& other) const; + virtual bool operator==(const Format& other) const; using Format::format; diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/plurfmt.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/plurfmt.h index 6faa5ad49..f8d3e1779 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/plurfmt.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/plurfmt.h @@ -434,7 +434,7 @@ class U_I18N_API PluralFormat : public Format { * @return true if other is semantically equal to this. * @stable ICU 4.0 */ - virtual UBool operator==(const Format& other) const; + virtual bool operator==(const Format& other) const; /** * Return true if another object is semantically unequal to this one. @@ -443,7 +443,7 @@ class U_I18N_API PluralFormat : public Format { * @return true if other is semantically unequal to this. * @stable ICU 4.0 */ - virtual UBool operator!=(const Format& other) const; + virtual bool operator!=(const Format& other) const; /** * Clones this Format object polymorphically. The caller owns the diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/plurrule.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/plurrule.h index 4e1ef017b..c299470b8 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/plurrule.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/plurrule.h @@ -484,7 +484,7 @@ class U_I18N_API PluralRules : public UObject { * PluralRules; false otherwise. * @stable ICU 4.0 */ - virtual UBool operator==(const PluralRules& other) const; + virtual bool operator==(const PluralRules& other) const; /** * Compares the inequality of two PluralRules objects. @@ -494,7 +494,7 @@ class U_I18N_API PluralRules : public UObject { * PluralRules; false otherwise. * @stable ICU 4.0 */ - UBool operator!=(const PluralRules& other) const {return !operator==(other);} + bool operator!=(const PluralRules& other) const {return !operator==(other);} /** diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/rbnf.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/rbnf.h index fa494957d..da5d900c8 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/rbnf.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/rbnf.h @@ -707,7 +707,7 @@ class U_I18N_API RuleBasedNumberFormat : public NumberFormat { * @return true if the given Format objects are semantically equal. * @stable ICU 2.6 */ - virtual UBool operator==(const Format& other) const; + virtual bool operator==(const Format& other) const; //----------------------------------------------------------------------- // public API functions diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/rbtz.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/rbtz.h index d66e1f08e..32129a50f 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/rbtz.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/rbtz.h @@ -76,7 +76,7 @@ class U_I18N_API RuleBasedTimeZone : public BasicTimeZone { *semantically equal. * @stable ICU 3.8 */ - virtual UBool operator==(const TimeZone& that) const; + virtual bool operator==(const TimeZone& that) const; /** * Return true if the given TimeZone objects are @@ -86,7 +86,7 @@ class U_I18N_API RuleBasedTimeZone : public BasicTimeZone { * semantically unequal. * @stable ICU 3.8 */ - virtual UBool operator!=(const TimeZone& that) const; + virtual bool operator!=(const TimeZone& that) const; /** * Adds the TimeZoneRule which represents time transitions. diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/region.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/region.h index 9ec8dd451..ba4a650f4 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/region.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/region.h @@ -81,13 +81,13 @@ class U_I18N_API Region : public UObject { * Returns true if the two regions are equal. * @stable ICU 51 */ - UBool operator==(const Region &that) const; + bool operator==(const Region &that) const; /** * Returns true if the two regions are NOT equal; that is, if operator ==() returns false. * @stable ICU 51 */ - UBool operator!=(const Region &that) const; + bool operator!=(const Region &that) const; /** * Returns a pointer to a Region using the given region code. The region code can be either 2-letter ISO code, diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/search.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/search.h index 7e328bcd2..c79fbfdab 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/search.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/search.h @@ -272,7 +272,7 @@ // * attributes. FALSE otherwise. // * @stable ICU 2.0 // */ -// virtual UBool operator==(const SearchIterator &that) const; +// virtual bool operator==(const SearchIterator &that) const; // /** // * Not-equal operator. @@ -280,7 +280,7 @@ // * @return FALSE if operator== returns TRUE, and vice versa. // * @stable ICU 2.0 // */ -// UBool operator!=(const SearchIterator &that) const; +// bool operator!=(const SearchIterator &that) const; // // public methods ---------------------------------------------------- diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/selfmt.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/selfmt.h index 971be21c1..de77602fe 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/selfmt.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/selfmt.h @@ -259,7 +259,7 @@ class U_I18N_API SelectFormat : public Format { * @return true if other is semantically equal to this. * @stable ICU 4.4 */ - virtual UBool operator==(const Format& other) const; + virtual bool operator==(const Format& other) const; /** * Return true if another object is semantically unequal to this one. @@ -268,7 +268,7 @@ class U_I18N_API SelectFormat : public Format { * @return true if other is semantically unequal to this. * @stable ICU 4.4 */ - virtual UBool operator!=(const Format& other) const; + virtual bool operator!=(const Format& other) const; /** * Clones this Format object polymorphically. The caller owns the diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/simpletz.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/simpletz.h index 980a1b8c6..362489223 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/simpletz.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/simpletz.h @@ -111,7 +111,7 @@ class U_I18N_API SimpleTimeZone: public BasicTimeZone { * otherwise. * @stable ICU 2.0 */ - virtual UBool operator==(const TimeZone& that) const; + virtual bool operator==(const TimeZone& that) const; /** * Constructs a SimpleTimeZone with the given raw GMT offset and time zone ID, diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/smpdtfmt.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/smpdtfmt.h index 5549ffb4a..ad390213b 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/smpdtfmt.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/smpdtfmt.h @@ -876,7 +876,7 @@ class U_I18N_API SimpleDateFormat: public DateFormat { * @return true if the given Format objects are semantically equal. * @stable ICU 2.0 */ - virtual UBool operator==(const Format& other) const; + virtual bool operator==(const Format& other) const; using DateFormat::format; diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/sortkey.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/sortkey.h index 34ed7ee69..ee0e6a5ce 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/sortkey.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/sortkey.h @@ -145,7 +145,7 @@ class U_I18N_API CollationKey : public UObject { * @return Returns true if two collation keys are equal, false otherwise. * @stable ICU 2.0 */ - UBool operator==(const CollationKey& source) const; + bool operator==(const CollationKey& source) const; /** * Compare if two collation keys are not the same. @@ -153,7 +153,7 @@ class U_I18N_API CollationKey : public UObject { * @return Returns TRUE if two collation keys are different, FALSE otherwise. * @stable ICU 2.0 */ - UBool operator!=(const CollationKey& source) const; + bool operator!=(const CollationKey& source) const; /** @@ -316,7 +316,7 @@ class U_I18N_API CollationKey : public UObject { } fUnion; }; -inline UBool +inline bool CollationKey::operator!=(const CollationKey& other) const { return !(*this == other); diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/stsearch.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/stsearch.h index e3c812bfd..6dfcf7802 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/stsearch.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/stsearch.h @@ -297,7 +297,7 @@ // * while looking for the same pattern. // * @stable ICU 2.0 // */ -// virtual UBool operator==(const SearchIterator &that) const; +// virtual bool operator==(const SearchIterator &that) const; // // public get and set methods ---------------------------------------- diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/tblcoll.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/tblcoll.h index f5dc135bc..050b08a9a 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/tblcoll.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/tblcoll.h @@ -223,7 +223,7 @@ class U_I18N_API RuleBasedCollator : public Collator { * @return true if arguments is the same as this object. * @stable ICU 2.0 */ - virtual UBool operator==(const Collator& other) const; + virtual bool operator==(const Collator& other) const; /** * Makes a copy of this object. diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/timezone.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/timezone.h index 4d321186b..eb68485d6 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/timezone.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/timezone.h @@ -445,7 +445,7 @@ class U_I18N_API TimeZone : public UObject { * otherwise. * @stable ICU 2.0 */ - virtual UBool operator==(const TimeZone& that) const; + virtual bool operator==(const TimeZone& that) const; /** * Returns true if the two TimeZones are NOT equal; that is, if operator==() returns @@ -456,7 +456,7 @@ class U_I18N_API TimeZone : public UObject { * otherwise. * @stable ICU 2.0 */ - UBool operator!=(const TimeZone& that) const {return !operator==(that);} + bool operator!=(const TimeZone& that) const {return !operator==(that);} /** * Returns the TimeZone's adjusted GMT offset (i.e., the number of milliseconds to add diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/tmutamt.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/tmutamt.h index 8bcc684d3..13e49668d 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/tmutamt.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/tmutamt.h @@ -103,7 +103,7 @@ class U_I18N_API TimeUnitAmount: public Measure { * @return true if this object is equal to the given object. * @stable ICU 4.2 */ - virtual UBool operator==(const UObject& other) const; + virtual bool operator==(const UObject& other) const; /** @@ -112,7 +112,7 @@ class U_I18N_API TimeUnitAmount: public Measure { * @return true if this object is not equal to the given object. * @stable ICU 4.2 */ - UBool operator!=(const UObject& other) const; + bool operator!=(const UObject& other) const; /** @@ -160,7 +160,7 @@ class U_I18N_API TimeUnitAmount: public Measure { -inline UBool +inline bool TimeUnitAmount::operator!=(const UObject& other) const { return !operator==(other); } diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/tmutfmt.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/tmutfmt.h index ad871f7c0..b1be87c30 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/tmutfmt.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/tmutfmt.h @@ -141,7 +141,7 @@ class U_I18N_API TimeUnitFormat: public MeasureFormat { * @return true if the given Format objects are not semantically equal. * @deprecated ICU 53 */ - UBool operator!=(const Format& other) const; + bool operator!=(const Format& other) const; /** * Set the locale used for formatting or parsing. @@ -236,7 +236,7 @@ class U_I18N_API TimeUnitFormat: public MeasureFormat { friend struct TimeUnitFormatReadSink; }; -inline UBool +inline bool TimeUnitFormat::operator!=(const Format& other) const { return !operator==(other); } diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/tzfmt.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/tzfmt.h index 6d3863b1e..706f0a037 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/tzfmt.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/tzfmt.h @@ -299,7 +299,7 @@ class U_I18N_API TimeZoneFormat : public Format { * Objects of different subclasses are considered unequal. * @stable ICU 50 */ - virtual UBool operator==(const Format& other) const; + virtual bool operator==(const Format& other) const; /** * Clone this object polymorphically. The caller is responsible diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/tznames.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/tznames.h index 860494221..7bb4d7702 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/tznames.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/tznames.h @@ -142,7 +142,7 @@ class U_I18N_API TimeZoneNames : public UObject { * @return Return TRUE if the given Format objects are semantically equal. * @stable ICU 50 */ - virtual UBool operator==(const TimeZoneNames& other) const = 0; + virtual bool operator==(const TimeZoneNames& other) const = 0; /** * Return true if the given TimeZoneNames objects are not semantically @@ -151,7 +151,7 @@ class U_I18N_API TimeZoneNames : public UObject { * @return Return TRUE if the given Format objects are not semantically equal. * @stable ICU 50 */ - UBool operator!=(const TimeZoneNames& other) const { return !operator==(other); } + bool operator!=(const TimeZoneNames& other) const { return !operator==(other); } /** * Clone this object polymorphically. The caller is responsible diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/tzrule.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/tzrule.h index 795806d90..45c5ab3e0 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/tzrule.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/tzrule.h @@ -56,7 +56,7 @@ class U_I18N_API TimeZoneRule : public UObject { * @return true if the given TimeZoneRule objects are semantically equal. * @stable ICU 3.8 */ - virtual UBool operator==(const TimeZoneRule& that) const; + virtual bool operator==(const TimeZoneRule& that) const; /** * Return true if the given TimeZoneRule objects are semantically unequal. Objects @@ -65,7 +65,7 @@ class U_I18N_API TimeZoneRule : public UObject { * @return true if the given TimeZoneRule objects are semantically unequal. * @stable ICU 3.8 */ - virtual UBool operator!=(const TimeZoneRule& that) const; + virtual bool operator!=(const TimeZoneRule& that) const; /** * Fills in "name" with the name of this time zone. @@ -247,7 +247,7 @@ class U_I18N_API InitialTimeZoneRule : public TimeZoneRule { * @return true if the given TimeZoneRule objects are semantically equal. * @stable ICU 3.8 */ - virtual UBool operator==(const TimeZoneRule& that) const; + virtual bool operator==(const TimeZoneRule& that) const; /** * Return true if the given TimeZoneRule objects are semantically unequal. Objects @@ -256,7 +256,7 @@ class U_I18N_API InitialTimeZoneRule : public TimeZoneRule { * @return true if the given TimeZoneRule objects are semantically unequal. * @stable ICU 3.8 */ - virtual UBool operator!=(const TimeZoneRule& that) const; + virtual bool operator!=(const TimeZoneRule& that) const; /** * Gets the time when this rule takes effect in the given year. @@ -458,7 +458,7 @@ class U_I18N_API AnnualTimeZoneRule : public TimeZoneRule { * @return true if the given TimeZoneRule objects are semantically equal. * @stable ICU 3.8 */ - virtual UBool operator==(const TimeZoneRule& that) const; + virtual bool operator==(const TimeZoneRule& that) const; /** * Return true if the given TimeZoneRule objects are semantically unequal. Objects @@ -467,7 +467,7 @@ class U_I18N_API AnnualTimeZoneRule : public TimeZoneRule { * @return true if the given TimeZoneRule objects are semantically unequal. * @stable ICU 3.8 */ - virtual UBool operator!=(const TimeZoneRule& that) const; + virtual bool operator!=(const TimeZoneRule& that) const; /** * Gets the start date/time rule used by this rule. @@ -674,7 +674,7 @@ class U_I18N_API TimeArrayTimeZoneRule : public TimeZoneRule { * @return true if the given TimeZoneRule objects are semantically equal. * @stable ICU 3.8 */ - virtual UBool operator==(const TimeZoneRule& that) const; + virtual bool operator==(const TimeZoneRule& that) const; /** * Return true if the given TimeZoneRule objects are semantically unequal. Objects @@ -683,7 +683,7 @@ class U_I18N_API TimeArrayTimeZoneRule : public TimeZoneRule { * @return true if the given TimeZoneRule objects are semantically unequal. * @stable ICU 3.8 */ - virtual UBool operator!=(const TimeZoneRule& that) const; + virtual bool operator!=(const TimeZoneRule& that) const; /** * Gets the time type of the start times used by this rule. The return value diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/tztrans.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/tztrans.h index 217d711ee..03d961846 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/tztrans.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/tztrans.h @@ -86,7 +86,7 @@ class U_I18N_API TimeZoneTransition : public UObject { * @return true if the given TimeZoneTransition objects are semantically equal. * @stable ICU 3.8 */ - UBool operator==(const TimeZoneTransition& that) const; + bool operator==(const TimeZoneTransition& that) const; /** * Return true if the given TimeZoneTransition objects are semantically unequal. Objects @@ -95,7 +95,7 @@ class U_I18N_API TimeZoneTransition : public UObject { * @return true if the given TimeZoneTransition objects are semantically unequal. * @stable ICU 3.8 */ - UBool operator!=(const TimeZoneTransition& that) const; + bool operator!=(const TimeZoneTransition& that) const; /** * Returns the time of transition in milliseconds. diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/vtzone.h b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/vtzone.h index 2743b6c47..7ed070624 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/unicode/vtzone.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/unicode/vtzone.h @@ -72,7 +72,7 @@ class U_I18N_API VTimeZone : public BasicTimeZone { *semantically equal. * @stable ICU 3.8 */ - virtual UBool operator==(const TimeZone& that) const; + virtual bool operator==(const TimeZone& that) const; /** * Return true if the given TimeZone objects are @@ -82,7 +82,7 @@ class U_I18N_API VTimeZone : public BasicTimeZone { * semantically unequal. * @stable ICU 3.8 */ - virtual UBool operator!=(const TimeZone& that) const; + virtual bool operator!=(const TimeZone& that) const; /** * Create a VTimeZone instance by the time zone ID. diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/utf16collationiterator.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/utf16collationiterator.cpp index 7598b0ee5..daa575c5f 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/utf16collationiterator.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/utf16collationiterator.cpp @@ -37,7 +37,7 @@ UTF16CollationIterator::UTF16CollationIterator(const UTF16CollationIterator &oth UTF16CollationIterator::~UTF16CollationIterator() {} -UBool +bool UTF16CollationIterator::operator==(const CollationIterator &other) const { if(!CollationIterator::operator==(other)) { return FALSE; } const UTF16CollationIterator &o = static_cast(other); @@ -171,7 +171,7 @@ FCDUTF16CollationIterator::FCDUTF16CollationIterator(const FCDUTF16CollationIter FCDUTF16CollationIterator::~FCDUTF16CollationIterator() {} -UBool +bool FCDUTF16CollationIterator::operator==(const CollationIterator &other) const { // Skip the UTF16CollationIterator and call its parent. if(!CollationIterator::operator==(other)) { return FALSE; } diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/utf16collationiterator.h b/src/duckdb/extension/icu/third_party/icu/i18n/utf16collationiterator.h index fd3a05e9e..31361099b 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/utf16collationiterator.h +++ b/src/duckdb/extension/icu/third_party/icu/i18n/utf16collationiterator.h @@ -42,7 +42,7 @@ class U_I18N_API UTF16CollationIterator : public CollationIterator { virtual ~UTF16CollationIterator(); - virtual UBool operator==(const CollationIterator &other) const; + virtual bool operator==(const CollationIterator &other) const; virtual void resetToOffset(int32_t newOffset); @@ -95,7 +95,7 @@ class U_I18N_API FCDUTF16CollationIterator : public UTF16CollationIterator { virtual ~FCDUTF16CollationIterator(); - virtual UBool operator==(const CollationIterator &other) const; + virtual bool operator==(const CollationIterator &other) const; virtual void resetToOffset(int32_t newOffset); diff --git a/src/duckdb/extension/icu/third_party/icu/i18n/vtzone.cpp b/src/duckdb/extension/icu/third_party/icu/i18n/vtzone.cpp index ccfa6b715..b9b0464a1 100644 --- a/src/duckdb/extension/icu/third_party/icu/i18n/vtzone.cpp +++ b/src/duckdb/extension/icu/third_party/icu/i18n/vtzone.cpp @@ -1038,7 +1038,7 @@ VTimeZone::operator=(const VTimeZone& right) { return *this; } -UBool +bool VTimeZone::operator==(const TimeZone& that) const { if (this == &that) { return TRUE; @@ -1057,7 +1057,7 @@ VTimeZone::operator==(const TimeZone& that) const { return FALSE; } -UBool +bool VTimeZone::operator!=(const TimeZone& that) const { return !operator==(that); } diff --git a/src/duckdb/extension/json/json_scan.cpp b/src/duckdb/extension/json/json_scan.cpp index d038885d9..6fd732a0b 100644 --- a/src/duckdb/extension/json/json_scan.cpp +++ b/src/duckdb/extension/json/json_scan.cpp @@ -206,11 +206,15 @@ unique_ptr JSONGlobalTableFunctionState::Init(ClientCo gstate.json_readers.emplace_back(reader.get()); } - vector dummy_types(input.column_ids.size(), LogicalType::ANY); + vector dummy_global_types(bind_data.names.size(), LogicalType::ANY); + vector dummy_local_types(gstate.names.size(), LogicalType::ANY); + auto local_columns = MultiFileReaderColumnDefinition::ColumnsFromNamesAndTypes(gstate.names, dummy_local_types); + auto global_columns = + MultiFileReaderColumnDefinition::ColumnsFromNamesAndTypes(bind_data.names, dummy_global_types); for (auto &reader : gstate.json_readers) { MultiFileReader().FinalizeBind(reader->GetOptions().file_options, gstate.bind_data.reader_bind, - reader->GetFileName(), gstate.names, dummy_types, bind_data.names, - input.column_indexes, reader->reader_data, context, nullptr); + reader->GetFileName(), local_columns, global_columns, input.column_indexes, + reader->reader_data, context, nullptr); } return std::move(result); diff --git a/src/duckdb/extension/parquet/column_writer.cpp b/src/duckdb/extension/parquet/column_writer.cpp index 677bacf42..5ba51a7c1 100644 --- a/src/duckdb/extension/parquet/column_writer.cpp +++ b/src/duckdb/extension/parquet/column_writer.cpp @@ -1311,21 +1311,26 @@ class StandardColumnWriter : public BasicColumnWriter { auto &state = state_p.Cast>(); if (state.dictionary.size() == 0 || state.dictionary.size() > writer.DictionarySizeLimit()) { - // If we aren't doing dictionary encoding, the following encodings are virtually always better than PLAIN - switch (type) { - case Type::type::INT32: - case Type::type::INT64: - state.encoding = Encoding::DELTA_BINARY_PACKED; - break; - case Type::type::BYTE_ARRAY: - state.encoding = Encoding::DELTA_LENGTH_BYTE_ARRAY; - break; - case Type::type::FLOAT: - case Type::type::DOUBLE: - state.encoding = Encoding::BYTE_STREAM_SPLIT; - break; - default: + if (writer.GetParquetVersion() == ParquetVersion::V1) { + // Can't do the cool stuff for V1 state.encoding = Encoding::PLAIN; + } else { + // If we aren't doing dictionary encoding, these encodings are virtually always better than PLAIN + switch (type) { + case Type::type::INT32: + case Type::type::INT64: + state.encoding = Encoding::DELTA_BINARY_PACKED; + break; + case Type::type::BYTE_ARRAY: + state.encoding = Encoding::DELTA_LENGTH_BYTE_ARRAY; + break; + case Type::type::FLOAT: + case Type::type::DOUBLE: + state.encoding = Encoding::BYTE_STREAM_SPLIT; + break; + default: + state.encoding = Encoding::PLAIN; + } } state.dictionary.clear(); } diff --git a/src/duckdb/extension/parquet/include/parquet_reader.hpp b/src/duckdb/extension/parquet/include/parquet_reader.hpp index 79de2b4cc..df537ea04 100644 --- a/src/duckdb/extension/parquet/include/parquet_reader.hpp +++ b/src/duckdb/extension/parquet/include/parquet_reader.hpp @@ -71,10 +71,12 @@ struct ParquetColumnDefinition { static ParquetColumnDefinition FromSchemaValue(ClientContext &context, const Value &column_value); public: + // DEPRECATED, use 'identifier' instead int32_t field_id; string name; LogicalType type; Value default_value; + Value identifier; public: void Serialize(Serializer &serializer) const; @@ -127,16 +129,13 @@ class ParquetReader { FileSystem &fs; Allocator &allocator; string file_name; - vector return_types; - vector names; + vector columns; shared_ptr metadata; ParquetOptions parquet_options; MultiFileReaderData reader_data; unique_ptr root_reader; shared_ptr encryption_util; - //! Index of the file_row_number column - idx_t file_row_number_idx = DConstants::INVALID_INDEX; //! Parquet schema for the generated columns vector generated_column_schema; //! Table column names - set when using COPY tbl FROM file.parquet @@ -150,17 +149,23 @@ class ParquetReader { auto result = make_uniq(); result->file_name = reader_p->file_name; if (file_idx == 0) { - result->names = reader_p->names; - result->types = reader_p->return_types; + for (auto &column : reader_p->columns) { + result->names.push_back(column.name); + result->types.push_back(column.type); + } result->options = reader_p->parquet_options; result->metadata = reader_p->metadata; result->reader = std::move(reader_p); } else { - result->names = std::move(reader_p->names); - result->types = std::move(reader_p->return_types); + for (auto &column : reader_p->columns) { + result->names.push_back(column.name); + result->types.push_back(column.type); + } + reader_p->columns.clear(); result->options = std::move(reader_p->parquet_options); result->metadata = std::move(reader_p->metadata); } + return result; } @@ -183,11 +188,9 @@ class ParquetReader { const string &GetFileName() { return file_name; } - const vector &GetNames() { - return names; - } - const vector &GetTypes() { - return return_types; + + const vector &GetColumns() { + return columns; } static unique_ptr ReadStatistics(ClientContext &context, ParquetOptions parquet_options, diff --git a/src/duckdb/extension/parquet/include/parquet_writer.hpp b/src/duckdb/extension/parquet/include/parquet_writer.hpp index e601926b2..f638b2f6b 100644 --- a/src/duckdb/extension/parquet/include/parquet_writer.hpp +++ b/src/duckdb/extension/parquet/include/parquet_writer.hpp @@ -68,13 +68,19 @@ struct ParquetBloomFilterEntry { idx_t column_idx; }; +enum class ParquetVersion : uint8_t { + V1 = 1, //! Excludes DELTA_BINARY_PACKED, DELTA_LENGTH_BYTE_ARRAY, BYTE_STREAM_SPLIT + V2 = 2, //! Includes the encodings above +}; + class ParquetWriter { public: ParquetWriter(ClientContext &context, FileSystem &fs, string file_name, vector types, vector names, duckdb_parquet::CompressionCodec::type codec, ChildFieldIDs field_ids, const vector> &kv_metadata, shared_ptr encryption_config, idx_t dictionary_size_limit, - double bloom_filter_false_positive_ratio, int64_t compression_level, bool debug_use_openssl); + double bloom_filter_false_positive_ratio, int64_t compression_level, bool debug_use_openssl, + ParquetVersion parquet_version); public: void PrepareRowGroup(ColumnDataCollection &buffer, PreparedRowGroup &result); @@ -117,6 +123,9 @@ class ParquetWriter { lock_guard glock(lock); return file_meta_data.row_groups.size(); } + ParquetVersion GetParquetVersion() const { + return parquet_version; + } uint32_t Write(const duckdb_apache::thrift::TBase &object); uint32_t WriteData(const const_data_ptr_t buffer, const uint32_t buffer_size); @@ -140,6 +149,7 @@ class ParquetWriter { int64_t compression_level; bool debug_use_openssl; shared_ptr encryption_util; + ParquetVersion parquet_version; unique_ptr writer; std::shared_ptr protocol; diff --git a/src/duckdb/extension/parquet/parquet_extension.cpp b/src/duckdb/extension/parquet/parquet_extension.cpp index 500b89919..8ec9924a6 100644 --- a/src/duckdb/extension/parquet/parquet_extension.cpp +++ b/src/duckdb/extension/parquet/parquet_extension.cpp @@ -5,6 +5,7 @@ #include "cast_column_reader.hpp" #include "duckdb.hpp" #include "duckdb/parser/expression/positional_reference_expression.hpp" +#include "duckdb/parser/expression/constant_expression.hpp" #include "duckdb/parser/query_node/select_node.hpp" #include "duckdb/parser/tableref/subqueryref.hpp" #include "duckdb/planner/operator/logical_projection.hpp" @@ -60,6 +61,7 @@ struct ParquetReadBindData : public TableFunctionData { atomic chunk_count; vector names; vector types; + vector columns; //! Table column names - set when using COPY tbl FROM file.parquet vector table_columns; @@ -201,6 +203,9 @@ struct ParquetWriteBindData : public TableFunctionData { ChildFieldIDs field_ids; //! The compression level, higher value is more int64_t compression_level = ZStdFileSystem::DefaultCompressionLevel(); + + //! Which encodings to include when writing + ParquetVersion parquet_version = ParquetVersion::V1; }; struct ParquetWriteGlobalState : public GlobalFunctionData { @@ -263,15 +268,47 @@ static MultiFileReaderBindData BindSchema(ClientContext &context, vector schema_col_names; vector schema_col_types; + MultiFileReaderBindData bind_data; schema_col_names.reserve(options.schema.size()); schema_col_types.reserve(options.schema.size()); - for (const auto &column : options.schema) { + bool match_by_field_id; + if (!options.schema.empty()) { + auto &column = options.schema[0]; + if (column.identifier.type().id() == LogicalTypeId::INTEGER) { + match_by_field_id = true; + } else { + match_by_field_id = false; + } + } else { + match_by_field_id = false; + } + + for (idx_t i = 0; i < options.schema.size(); i++) { + const auto &column = options.schema[i]; schema_col_names.push_back(column.name); schema_col_types.push_back(column.type); + + auto res = MultiFileReaderColumnDefinition(column.name, column.type); + res.identifier = column.identifier; +#ifdef DEBUG + if (match_by_field_id) { + D_ASSERT(res.identifier.type().id() == LogicalTypeId::INTEGER); + } else { + D_ASSERT(res.identifier.type().id() == LogicalTypeId::VARCHAR); + } +#endif + + res.default_expression = make_uniq(column.default_value); + bind_data.schema.emplace_back(std::move(res)); + } + + if (match_by_field_id) { + bind_data.mapping = MultiFileReaderColumnMappingMode::BY_FIELD_ID; + } else { + bind_data.mapping = MultiFileReaderColumnMappingMode::BY_NAME; } // perform the binding on the obtained set of names + types - MultiFileReaderBindData bind_data; result.multi_file_reader->BindOptions(options.file_options, *result.file_list, schema_col_types, schema_col_names, bind_data); @@ -295,85 +332,13 @@ static void InitializeParquetReader(ParquetReader &reader, const ParquetReadBind // Mark the file in the file list we are scanning here reader_data.file_list_idx = file_idx; - if (bind_data.parquet_options.schema.empty()) { - bind_data.multi_file_reader->InitializeReader( - reader, parquet_options.file_options, bind_data.reader_bind, bind_data.types, bind_data.names, - global_column_ids, table_filters, bind_data.file_list->GetFirstFile(), context, reader_state); - return; - } - - // a fixed schema was supplied, initialize the MultiFileReader settings here so we can read using the schema - - // this deals with hive partitioning and filename=true - bind_data.multi_file_reader->FinalizeBind(parquet_options.file_options, bind_data.reader_bind, reader.GetFileName(), - reader.GetNames(), bind_data.types, bind_data.names, global_column_ids, - reader_data, context, reader_state); - - // create a mapping from field id to column index in file - unordered_map field_id_to_column_index; - auto &column_readers = reader.root_reader->Cast().child_readers; - for (idx_t column_index = 0; column_index < column_readers.size(); column_index++) { - auto &column_reader = *column_readers[column_index]; - auto &column_schema = column_reader.Schema(); - if (column_schema.__isset.field_id) { - field_id_to_column_index[column_schema.field_id] = column_index; - } else if (column_reader.GetParentSchema()) { - auto &parent_column_schema = *column_reader.GetParentSchema(); - if (parent_column_schema.__isset.field_id) { - field_id_to_column_index[parent_column_schema.field_id] = column_index; - } - } - } - - // loop through the schema definition - for (idx_t i = 0; i < global_column_ids.size(); i++) { - auto global_column_index = global_column_ids[i].GetPrimaryIndex(); - - // check if this is a constant column - bool constant = false; - for (auto &entry : reader_data.constant_map) { - if (entry.column_id == i) { - constant = true; - break; - } - } - if (constant) { - // this column is constant for this file - continue; - } - - // Handle any generate columns that are not in the schema (currently only file_row_number) - if (global_column_index >= parquet_options.schema.size()) { - if (bind_data.reader_bind.file_row_number_idx == global_column_index) { - reader_data.column_mapping.push_back(i); - reader_data.column_ids.push_back(reader.file_row_number_idx); - } - continue; - } - - const auto &column_definition = parquet_options.schema[global_column_index]; - auto it = field_id_to_column_index.find(column_definition.field_id); - if (it == field_id_to_column_index.end()) { - // field id not present in file, use default value - reader_data.constant_map.emplace_back(i, column_definition.default_value); - continue; - } - - const auto &local_column_index = it->second; - auto &column_reader = column_readers[local_column_index]; - if (column_reader->Type() != column_definition.type) { - // differing types, wrap in a cast column reader - reader_data.cast_map[local_column_index] = column_definition.type; - } - - reader_data.column_mapping.push_back(i); - reader_data.column_ids.push_back(local_column_index); - } - reader_data.empty_columns = reader_data.column_ids.empty(); - - // Finally, initialize the filters - bind_data.multi_file_reader->CreateFilterMap(bind_data.types, table_filters, reader_data, reader_state); - reader_data.filters = table_filters; + // 'reader_bind.schema' could be set explicitly by: + // 1. The MultiFileReader::Bind call + // 2. The 'schema' parquet option + auto &global_columns = bind_data.reader_bind.schema.empty() ? bind_data.columns : bind_data.reader_bind.schema; + bind_data.multi_file_reader->InitializeReader(reader, parquet_options.file_options, bind_data.reader_bind, + global_columns, global_column_ids, table_filters, + bind_data.file_list->GetFirstFile(), context, reader_state); } static bool GetBooleanArgument(const pair> &option) { @@ -407,11 +372,9 @@ class ParquetScanFunction { table_function.named_parameters["debug_use_openssl"] = LogicalType::BOOLEAN; table_function.named_parameters["compression"] = LogicalType::VARCHAR; table_function.named_parameters["explicit_cardinality"] = LogicalType::UBIGINT; - table_function.named_parameters["schema"] = - LogicalType::MAP(LogicalType::INTEGER, LogicalType::STRUCT({{{"name", LogicalType::VARCHAR}, - {"type", LogicalType::VARCHAR}, - {"default_value", LogicalType::VARCHAR}}})); + table_function.named_parameters["schema"] = LogicalTypeId::ANY; table_function.named_parameters["encryption_config"] = LogicalTypeId::ANY; + table_function.named_parameters["parquet_version"] = LogicalType::VARCHAR; table_function.get_partition_data = ParquetScanGetPartitionData; table_function.serialize = ParquetScanSerialize; table_function.deserialize = ParquetScanDeserialize; @@ -515,16 +478,21 @@ class ParquetScanFunction { result->reader_bind = result->multi_file_reader->BindReader( context, result->types, result->names, *result->file_list, *result, parquet_options); } + + // Set the explicit cardinality if requested if (parquet_options.explicit_cardinality) { auto file_count = result->file_list->GetTotalFileCount(); result->explicit_cardinality = parquet_options.explicit_cardinality; result->initial_file_cardinality = result->explicit_cardinality / (file_count ? file_count : 1); } + if (return_types.empty()) { // no expected types - just copy the types return_types = result->types; names = result->names; } else { + // We're deserializing from a previously successful bind call + // verify that the amount of columns still matches if (return_types.size() != result->types.size()) { auto file_string = bound_on_first_file ? result->file_list->GetFirstFile() : StringUtil::Join(result->file_list->GetPaths(), ","); @@ -555,9 +523,56 @@ class ParquetScanFunction { result->table_columns = names; } result->parquet_options = parquet_options; + result->columns = MultiFileReaderColumnDefinition::ColumnsFromNamesAndTypes(result->names, result->types); return std::move(result); } + static void VerifyParquetSchemaParameter(const Value &schema) { + LogicalType::MAP(LogicalType::BLOB, LogicalType::STRUCT({{{"name", LogicalType::VARCHAR}, + {"type", LogicalType::VARCHAR}, + {"default_value", LogicalType::VARCHAR}}})); + auto &map_type = schema.type(); + if (map_type.id() != LogicalTypeId::MAP) { + throw InvalidInputException("'schema' expects a value of type MAP, not %s", + LogicalTypeIdToString(map_type.id())); + } + auto &key_type = MapType::KeyType(map_type); + auto &value_type = MapType::ValueType(map_type); + + if (value_type.id() != LogicalTypeId::STRUCT) { + throw InvalidInputException("'schema' expects a STRUCT as the value type of the map"); + } + auto &children = StructType::GetChildTypes(value_type); + if (children.size() < 3) { + throw InvalidInputException( + "'schema' expects the STRUCT to have 3 children, 'name', 'type' and 'default_value"); + } + if (!StringUtil::CIEquals(children[0].first, "name")) { + throw InvalidInputException("'schema' expects the first field of the struct to be called 'name'"); + } + if (children[0].second.id() != LogicalTypeId::VARCHAR) { + throw InvalidInputException("'schema' expects the 'name' field to be of type VARCHAR, not %s", + LogicalTypeIdToString(children[0].second.id())); + } + if (!StringUtil::CIEquals(children[1].first, "type")) { + throw InvalidInputException("'schema' expects the second field of the struct to be called 'type'"); + } + if (children[1].second.id() != LogicalTypeId::VARCHAR) { + throw InvalidInputException("'schema' expects the 'type' field to be of type VARCHAR, not %s", + LogicalTypeIdToString(children[1].second.id())); + } + if (!StringUtil::CIEquals(children[2].first, "default_value")) { + throw InvalidInputException("'schema' expects the third field of the struct to be called 'default_value'"); + } + //! NOTE: default_value can be any type + + if (key_type.id() != LogicalTypeId::INTEGER && key_type.id() != LogicalTypeId::VARCHAR) { + throw InvalidInputException( + "'schema' expects the value type of the map to be either INTEGER or VARCHAR, not %s", + LogicalTypeIdToString(key_type.id())); + } + } + static unique_ptr ParquetScanBind(ClientContext &context, TableFunctionBindInput &input, vector &return_types, vector &names) { auto multi_file_reader = MultiFileReader::Create(input.table_function); @@ -580,6 +595,7 @@ class ParquetScanFunction { } else if (loption == "schema") { // Argument is a map that defines the schema const auto &schema_value = kv.second; + VerifyParquetSchemaParameter(schema_value); const auto column_values = ListValue::GetChildren(schema_value); if (column_values.empty()) { throw BinderException("Parquet schema cannot be empty"); @@ -666,9 +682,11 @@ class ParquetScanFunction { auto &file_list = result->file_list; file_list.InitializeScan(result->file_list_scan); + auto &global_columns = bind_data.reader_bind.schema.empty() ? bind_data.columns : bind_data.reader_bind.schema; result->multi_file_reader_state = bind_data.multi_file_reader->InitializeGlobalState( - context, bind_data.parquet_options.file_options, bind_data.reader_bind, file_list, bind_data.types, - bind_data.names, input.column_indexes); + context, bind_data.parquet_options.file_options, bind_data.reader_bind, file_list, global_columns, + input.column_indexes); + if (file_list.IsEmpty()) { result->readers = {}; } else if (!bind_data.union_readers.empty()) { @@ -1275,6 +1293,15 @@ unique_ptr ParquetWriteBind(ClientContext &context, CopyFunctionBi } bind_data->compression_level = val; compression_level_set = true; + } else if (loption == "parquet_version") { + const auto roption = StringUtil::Upper(option.second[0].ToString()); + if (roption == "V1") { + bind_data->parquet_version = ParquetVersion::V1; + } else if (roption == "V2") { + bind_data->parquet_version = ParquetVersion::V2; + } else { + throw BinderException("Expected parquet_version 'V1' or 'V2'"); + } } else { throw NotImplementedException("Unrecognized option for PARQUET: %s", option.first.c_str()); } @@ -1305,7 +1332,7 @@ unique_ptr ParquetWriteInitializeGlobal(ClientContext &conte context, fs, file_path, parquet_bind.sql_types, parquet_bind.column_names, parquet_bind.codec, parquet_bind.field_ids.Copy(), parquet_bind.kv_metadata, parquet_bind.encryption_config, parquet_bind.dictionary_size_limit, parquet_bind.bloom_filter_false_positive_ratio, - parquet_bind.compression_level, parquet_bind.debug_use_openssl); + parquet_bind.compression_level, parquet_bind.debug_use_openssl, parquet_bind.parquet_version); return std::move(global_state); } @@ -1410,6 +1437,29 @@ duckdb_parquet::CompressionCodec::type EnumUtil::FromString +const char *EnumUtil::ToChars(ParquetVersion value) { + switch (value) { + case ParquetVersion::V1: + return "V1"; + case ParquetVersion::V2: + return "V2"; + default: + throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value)); + } +} + +template <> +ParquetVersion EnumUtil::FromString(const char *value) { + if (StringUtil::Equals(value, "V1")) { + return ParquetVersion::V1; + } + if (StringUtil::Equals(value, "V2")) { + return ParquetVersion::V2; + } + throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented", value)); +} + static optional_idx SerializeCompressionLevel(const int64_t compression_level) { return compression_level < 0 ? NumericLimits::Maximum() - NumericCast(AbsValue(compression_level)) : NumericCast(compression_level); @@ -1441,13 +1491,24 @@ static void ParquetCopySerialize(Serializer &serializer, const FunctionData &bin bind_data.encryption_config, nullptr); // 108 was dictionary_compression_ratio_threshold, but was deleted + + // To avoid doubly defining the default values in both ParquetWriteBindData and here, + // and possibly making a mistake, we just get the values from ParquetWriteBindData. + // We have to std::move them, otherwise MSVC will complain that it's not a "const T &&" const auto compression_level = SerializeCompressionLevel(bind_data.compression_level); D_ASSERT(DeserializeCompressionLevel(compression_level) == bind_data.compression_level); - serializer.WritePropertyWithDefault(109, "compression_level", compression_level); - serializer.WriteProperty(110, "row_groups_per_file", bind_data.row_groups_per_file); - serializer.WriteProperty(111, "debug_use_openssl", bind_data.debug_use_openssl); - serializer.WriteProperty(112, "dictionary_size_limit", bind_data.dictionary_size_limit); - serializer.WriteProperty(113, "bloom_filter_false_positive_ratio", bind_data.bloom_filter_false_positive_ratio); + serializer.WritePropertyWithDefault(109, "compression_level", compression_level); + serializer.WritePropertyWithDefault(110, "row_groups_per_file", bind_data.row_groups_per_file, + std::move(ParquetWriteBindData().row_groups_per_file)); + serializer.WritePropertyWithDefault(111, "debug_use_openssl", bind_data.debug_use_openssl, + std::move(ParquetWriteBindData().debug_use_openssl)); + serializer.WritePropertyWithDefault(112, "dictionary_size_limit", bind_data.dictionary_size_limit, + std::move(ParquetWriteBindData().dictionary_size_limit)); + serializer.WritePropertyWithDefault(113, "bloom_filter_false_positive_ratio", + bind_data.bloom_filter_false_positive_ratio, + std::move(ParquetWriteBindData().bloom_filter_false_positive_ratio)); + serializer.WritePropertyWithDefault(114, "parquet_version", bind_data.parquet_version, + std::move(ParquetWriteBindData().parquet_version)); } static unique_ptr ParquetCopyDeserialize(Deserializer &deserializer, CopyFunction &function) { @@ -1459,21 +1520,24 @@ static unique_ptr ParquetCopyDeserialize(Deserializer &deserialize data->row_group_size_bytes = deserializer.ReadProperty(104, "row_group_size_bytes"); data->kv_metadata = deserializer.ReadProperty>>(105, "kv_metadata"); data->field_ids = deserializer.ReadProperty(106, "field_ids"); - deserializer.ReadPropertyWithExplicitDefault>(107, "encryption_config", - data->encryption_config, nullptr); + deserializer.ReadPropertyWithExplicitDefault>( + 107, "encryption_config", data->encryption_config, std::move(ParquetWriteBindData().encryption_config)); deserializer.ReadDeletedProperty(108, "dictionary_compression_ratio_threshold"); optional_idx compression_level; deserializer.ReadPropertyWithDefault(109, "compression_level", compression_level); data->compression_level = DeserializeCompressionLevel(compression_level); D_ASSERT(SerializeCompressionLevel(data->compression_level) == compression_level); - data->row_groups_per_file = - deserializer.ReadPropertyWithExplicitDefault(110, "row_groups_per_file", optional_idx::Invalid()); - data->debug_use_openssl = deserializer.ReadPropertyWithExplicitDefault(111, "debug_use_openssl", true); - data->dictionary_size_limit = - deserializer.ReadPropertyWithExplicitDefault(112, "dictionary_size_limit", data->row_group_size / 10); - data->bloom_filter_false_positive_ratio = - deserializer.ReadPropertyWithExplicitDefault(113, "bloom_filter_false_positive_ratio", 0.01); + data->row_groups_per_file = deserializer.ReadPropertyWithExplicitDefault( + 110, "row_groups_per_file", std::move(ParquetWriteBindData().row_groups_per_file)); + data->debug_use_openssl = deserializer.ReadPropertyWithExplicitDefault( + 111, "debug_use_openssl", std::move(ParquetWriteBindData().debug_use_openssl)); + data->dictionary_size_limit = deserializer.ReadPropertyWithExplicitDefault( + 112, "dictionary_size_limit", std::move(ParquetWriteBindData().dictionary_size_limit)); + data->bloom_filter_false_positive_ratio = deserializer.ReadPropertyWithExplicitDefault( + 113, "bloom_filter_false_positive_ratio", std::move(ParquetWriteBindData().bloom_filter_false_positive_ratio)); + data->parquet_version = deserializer.ReadPropertyWithExplicitDefault( + 114, "parquet_version", std::move(ParquetWriteBindData().parquet_version)); return std::move(data); } diff --git a/src/duckdb/extension/parquet/parquet_metadata.cpp b/src/duckdb/extension/parquet/parquet_metadata.cpp index 456c9b3e4..31c7d0870 100644 --- a/src/duckdb/extension/parquet/parquet_metadata.cpp +++ b/src/duckdb/extension/parquet/parquet_metadata.cpp @@ -615,8 +615,8 @@ void ParquetMetaDataOperatorData::ExecuteBloomProbe(ClientContext &context, cons auto meta_data = reader->GetFileMetadata(); optional_idx probe_column_idx; - for (idx_t column_idx = 0; column_idx < reader->names.size(); column_idx++) { - if (reader->names[column_idx] == column_name) { + for (idx_t column_idx = 0; column_idx < reader->columns.size(); column_idx++) { + if (reader->columns[column_idx].name == column_name) { probe_column_idx = column_idx; } } @@ -632,7 +632,7 @@ void ParquetMetaDataOperatorData::ExecuteBloomProbe(ClientContext &context, cons D_ASSERT(!probe.IsNull()); ConstantFilter filter(ExpressionType::COMPARE_EQUAL, - probe.CastAs(context, reader->GetTypes()[probe_column_idx.GetIndex()])); + probe.CastAs(context, reader->GetColumns()[probe_column_idx.GetIndex()].type)); for (idx_t row_group_idx = 0; row_group_idx < meta_data->row_groups.size(); row_group_idx++) { auto &row_group = meta_data->row_groups[row_group_idx]; diff --git a/src/duckdb/extension/parquet/parquet_reader.cpp b/src/duckdb/extension/parquet/parquet_reader.cpp index 1d2565a2d..561386773 100644 --- a/src/duckdb/extension/parquet/parquet_reader.cpp +++ b/src/duckdb/extension/parquet/parquet_reader.cpp @@ -473,8 +473,6 @@ unique_ptr ParquetReader::CreateReader(ClientContext &context) { root_struct_reader.child_readers[column_idx] = std::move(cast_reader); } if (parquet_options.file_row_number) { - file_row_number_idx = root_struct_reader.child_readers.size(); - generated_column_schema.push_back(SchemaElement()); root_struct_reader.child_readers.push_back(make_uniq( *this, LogicalType::BIGINT, generated_column_schema.back(), next_file_idx, 0, 0)); @@ -499,20 +497,39 @@ void ParquetReader::InitializeSchema(ClientContext &context) { root_reader = CreateReader(context); auto &root_type = root_reader->Type(); auto &child_types = StructType::GetChildTypes(root_type); + + auto &struct_reader = root_reader->Cast(); + auto &child_readers = struct_reader.child_readers; D_ASSERT(root_type.id() == LogicalTypeId::STRUCT); - for (auto &type_pair : child_types) { - names.push_back(type_pair.first); - return_types.push_back(type_pair.second); + + D_ASSERT(child_readers.size() >= child_types.size()); + for (idx_t i = 0; i < child_types.size(); i++) { + auto &type_pair = child_types[i]; + auto column = MultiFileReaderColumnDefinition(type_pair.first, type_pair.second); + auto &column_reader = *child_readers[i]; + auto &column_schema = column_reader.Schema(); + + if (column_schema.__isset.field_id) { + column.identifier = Value::INTEGER(column_schema.field_id); + } else if (column_reader.GetParentSchema()) { + auto &parent_column_schema = *column_reader.GetParentSchema(); + if (parent_column_schema.__isset.field_id) { + column.identifier = Value::INTEGER(parent_column_schema.field_id); + } + } + columns.emplace_back(std::move(column)); } // Add generated constant column for row number if (parquet_options.file_row_number) { - if (StringUtil::CIFind(names, "file_row_number") != DConstants::INVALID_INDEX) { - throw BinderException( - "Using file_row_number option on file with column named file_row_number is not supported"); + for (auto &column : columns) { + auto &name = column.name; + if (StringUtil::CIEquals(name, "file_row_number")) { + throw BinderException( + "Using file_row_number option on file with column named file_row_number is not supported"); + } } - return_types.emplace_back(LogicalType::BIGINT); - names.emplace_back("file_row_number"); + columns.emplace_back("file_row_number", LogicalType::BIGINT); } } @@ -525,7 +542,8 @@ ParquetOptions::ParquetOptions(ClientContext &context) { ParquetColumnDefinition ParquetColumnDefinition::FromSchemaValue(ClientContext &context, const Value &column_value) { ParquetColumnDefinition result; - result.field_id = IntegerValue::Get(StructValue::GetChildren(column_value)[0]); + auto &identifier = StructValue::GetChildren(column_value)[0]; + result.identifier = identifier; const auto &column_def = StructValue::GetChildren(column_value)[1]; D_ASSERT(column_def.type().id() == LogicalTypeId::STRUCT); @@ -607,12 +625,12 @@ const FileMetaData *ParquetReader::GetFileMetadata() { unique_ptr ParquetReader::ReadStatistics(const string &name) { idx_t file_col_idx; - for (file_col_idx = 0; file_col_idx < names.size(); file_col_idx++) { - if (names[file_col_idx] == name) { + for (file_col_idx = 0; file_col_idx < columns.size(); file_col_idx++) { + if (columns[file_col_idx].name == name) { break; } } - if (file_col_idx == names.size()) { + if (file_col_idx == columns.size()) { return nullptr; } diff --git a/src/duckdb/extension/parquet/parquet_writer.cpp b/src/duckdb/extension/parquet/parquet_writer.cpp index 883f03069..f7e3651ec 100644 --- a/src/duckdb/extension/parquet/parquet_writer.cpp +++ b/src/duckdb/extension/parquet/parquet_writer.cpp @@ -321,12 +321,12 @@ ParquetWriter::ParquetWriter(ClientContext &context, FileSystem &fs, string file const vector> &kv_metadata, shared_ptr encryption_config_p, idx_t dictionary_size_limit_p, double bloom_filter_false_positive_ratio_p, int64_t compression_level_p, - bool debug_use_openssl_p) + bool debug_use_openssl_p, ParquetVersion parquet_version) : file_name(std::move(file_name_p)), sql_types(std::move(types_p)), column_names(std::move(names_p)), codec(codec), field_ids(std::move(field_ids_p)), encryption_config(std::move(encryption_config_p)), dictionary_size_limit(dictionary_size_limit_p), bloom_filter_false_positive_ratio(bloom_filter_false_positive_ratio_p), compression_level(compression_level_p), - debug_use_openssl(debug_use_openssl_p) { + debug_use_openssl(debug_use_openssl_p), parquet_version(parquet_version) { // initialize the file writer writer = make_uniq(fs, file_name.c_str(), diff --git a/src/duckdb/extension/parquet/serialize_parquet.cpp b/src/duckdb/extension/parquet/serialize_parquet.cpp index bcb334a45..5fa792cd3 100644 --- a/src/duckdb/extension/parquet/serialize_parquet.cpp +++ b/src/duckdb/extension/parquet/serialize_parquet.cpp @@ -40,6 +40,7 @@ void ParquetColumnDefinition::Serialize(Serializer &serializer) const { serializer.WritePropertyWithDefault(101, "name", name); serializer.WriteProperty(103, "type", type); serializer.WriteProperty(104, "default_value", default_value); + serializer.WritePropertyWithDefault(105, "identifier", identifier, Value()); } ParquetColumnDefinition ParquetColumnDefinition::Deserialize(Deserializer &deserializer) { @@ -48,6 +49,7 @@ ParquetColumnDefinition ParquetColumnDefinition::Deserialize(Deserializer &deser deserializer.ReadPropertyWithDefault(101, "name", result.name); deserializer.ReadProperty(103, "type", result.type); deserializer.ReadProperty(104, "default_value", result.default_value); + deserializer.ReadPropertyWithExplicitDefault(105, "identifier", result.identifier, Value()); return result; } diff --git a/src/duckdb/src/common/arrow/arrow_type_extension.cpp b/src/duckdb/src/common/arrow/arrow_type_extension.cpp index 4483f8644..8a9779b08 100644 --- a/src/duckdb/src/common/arrow/arrow_type_extension.cpp +++ b/src/duckdb/src/common/arrow/arrow_type_extension.cpp @@ -177,7 +177,7 @@ void ArrowTypeExtension::PopulateArrowSchema(DuckDBArrowSchemaHolder &root_holde } void DBConfig::RegisterArrowExtension(const ArrowTypeExtension &extension) const { - lock_guard l(encoding_functions->lock); + lock_guard l(arrow_extensions->lock); auto extension_info = extension.GetInfo(); if (arrow_extensions->type_extensions.find(extension_info) != arrow_extensions->type_extensions.end()) { throw NotImplementedException("Arrow Extension with configuration %s is already registered", @@ -193,27 +193,37 @@ void DBConfig::RegisterArrowExtension(const ArrowTypeExtension &extension) const arrow_extensions->type_to_info[type_info].push_back(extension_info); } -ArrowTypeExtension DBConfig::GetArrowExtension(ArrowExtensionMetadata info) const { - if (arrow_extensions->type_extensions.find(info) == arrow_extensions->type_extensions.end()) { +ArrowTypeExtension GetArrowExtensionInternal( + unordered_map &type_extensions, + ArrowExtensionMetadata info) { + if (type_extensions.find(info) == type_extensions.end()) { info.SetArrowFormat(""); - if (arrow_extensions->type_extensions.find(info) == arrow_extensions->type_extensions.end()) { + if (type_extensions.find(info) == type_extensions.end()) { throw NotImplementedException("Arrow Extension with configuration:\n%s not yet registered", info.ToString()); } } - return arrow_extensions->type_extensions[info]; + return type_extensions[info]; +} +ArrowTypeExtension DBConfig::GetArrowExtension(ArrowExtensionMetadata info) const { + lock_guard l(arrow_extensions->lock); + return GetArrowExtensionInternal(arrow_extensions->type_extensions, std::move(info)); } ArrowTypeExtension DBConfig::GetArrowExtension(const LogicalType &type) const { + lock_guard l(arrow_extensions->lock); TypeInfo type_info(type); if (!arrow_extensions->type_to_info[type_info].empty()) { - return GetArrowExtension(arrow_extensions->type_to_info[type_info].front()); + return GetArrowExtensionInternal(arrow_extensions->type_extensions, + arrow_extensions->type_to_info[type_info].front()); } type_info.type = LogicalTypeId::ANY; - return GetArrowExtension(arrow_extensions->type_to_info[type_info].front()); + return GetArrowExtensionInternal(arrow_extensions->type_extensions, + arrow_extensions->type_to_info[type_info].front()); } bool DBConfig::HasArrowExtension(const LogicalType &type) const { + lock_guard l(arrow_extensions->lock); TypeInfo type_info(type); if (!arrow_extensions->type_to_info[type_info].empty()) { return true; diff --git a/src/duckdb/src/common/enum_util.cpp b/src/duckdb/src/common/enum_util.cpp index c3a99f657..56f61fc12 100644 --- a/src/duckdb/src/common/enum_util.cpp +++ b/src/duckdb/src/common/enum_util.cpp @@ -66,6 +66,7 @@ #include "duckdb/common/file_buffer.hpp" #include "duckdb/common/file_open_flags.hpp" #include "duckdb/common/multi_file_list.hpp" +#include "duckdb/common/multi_file_reader_options.hpp" #include "duckdb/common/operator/decimal_cast_operators.hpp" #include "duckdb/common/printer.hpp" #include "duckdb/common/sort/partition_state.hpp" @@ -2415,6 +2416,24 @@ MetricsType EnumUtil::FromString(const char *value) { return static_cast(StringUtil::StringToEnum(GetMetricsTypeValues(), 49, "MetricsType", value)); } +const StringUtil::EnumStringLiteral *GetMultiFileReaderColumnMappingModeValues() { + static constexpr StringUtil::EnumStringLiteral values[] { + { static_cast(MultiFileReaderColumnMappingMode::BY_NAME), "BY_NAME" }, + { static_cast(MultiFileReaderColumnMappingMode::BY_FIELD_ID), "BY_FIELD_ID" } + }; + return values; +} + +template<> +const char* EnumUtil::ToChars(MultiFileReaderColumnMappingMode value) { + return StringUtil::EnumToString(GetMultiFileReaderColumnMappingModeValues(), 2, "MultiFileReaderColumnMappingMode", static_cast(value)); +} + +template<> +MultiFileReaderColumnMappingMode EnumUtil::FromString(const char *value) { + return static_cast(StringUtil::StringToEnum(GetMultiFileReaderColumnMappingModeValues(), 2, "MultiFileReaderColumnMappingMode", value)); +} + const StringUtil::EnumStringLiteral *GetNTypeValues() { static constexpr StringUtil::EnumStringLiteral values[] { { static_cast(NType::PREFIX), "PREFIX" }, diff --git a/src/duckdb/src/common/exception.cpp b/src/duckdb/src/common/exception.cpp index 991f929f2..494a669cb 100644 --- a/src/duckdb/src/common/exception.cpp +++ b/src/duckdb/src/common/exception.cpp @@ -36,7 +36,12 @@ string Exception::ToJSON(ExceptionType type, const string &message, const unorde #endif { auto extended_extra_info = extra_info; - extended_extra_info["stack_trace_pointers"] = StackTrace::GetStacktracePointers(); + // We only want to add the stack trace pointers if they are not already present, otherwise the original + // stack traces are lost + if (extended_extra_info.find("stack_trace_pointers") == extended_extra_info.end() && + extended_extra_info.find("stack_trace") == extended_extra_info.end()) { + extended_extra_info["stack_trace_pointers"] = StackTrace::GetStacktracePointers(); + } return StringUtil::ExceptionToJSONMap(type, message, extended_extra_info); } return StringUtil::ExceptionToJSONMap(type, message, extra_info); diff --git a/src/duckdb/src/common/multi_file_reader.cpp b/src/duckdb/src/common/multi_file_reader.cpp index 97eba1014..813d13f70 100644 --- a/src/duckdb/src/common/multi_file_reader.cpp +++ b/src/duckdb/src/common/multi_file_reader.cpp @@ -8,6 +8,7 @@ #include "duckdb/function/table_function.hpp" #include "duckdb/main/config.hpp" #include "duckdb/planner/expression/bound_columnref_expression.hpp" +#include "duckdb/parser/expression/constant_expression.hpp" #include "duckdb/common/string_util.hpp" #include @@ -235,16 +236,17 @@ void MultiFileReader::BindOptions(MultiFileReaderOptions &options, MultiFileList } void MultiFileReader::FinalizeBind(const MultiFileReaderOptions &file_options, const MultiFileReaderBindData &options, - const string &filename, const vector &local_names, - const vector &global_types, const vector &global_names, + const string &filename, const vector &local_columns, + const vector &global_columns, const vector &global_column_ids, MultiFileReaderData &reader_data, ClientContext &context, optional_ptr global_state) { // create a map of name -> column index case_insensitive_map_t name_map; if (file_options.union_by_name) { - for (idx_t col_idx = 0; col_idx < local_names.size(); col_idx++) { - name_map[local_names[col_idx]] = col_idx; + for (idx_t col_idx = 0; col_idx < local_columns.size(); col_idx++) { + auto &column = local_columns[col_idx]; + name_map[column.name] = col_idx; } } for (idx_t i = 0; i < global_column_ids.size(); i++) { @@ -278,13 +280,16 @@ void MultiFileReader::FinalizeBind(const MultiFileReaderOptions &file_options, c } } if (file_options.union_by_name) { - auto &global_name = global_names[column_id]; - auto entry = name_map.find(global_name); + auto &column = global_columns[column_id]; + auto &name = column.name; + auto &type = column.type; + + auto entry = name_map.find(name); bool not_present_in_file = entry == name_map.end(); if (not_present_in_file) { // we need to project a column with name \"global_name\" - but it does not exist in the current file // push a NULL value of the specified type - reader_data.constant_map.emplace_back(i, Value(global_types[column_id])); + reader_data.constant_map.emplace_back(i, Value(type)); continue; } } @@ -294,24 +299,25 @@ void MultiFileReader::FinalizeBind(const MultiFileReaderOptions &file_options, c unique_ptr MultiFileReader::InitializeGlobalState(ClientContext &context, const MultiFileReaderOptions &file_options, const MultiFileReaderBindData &bind_data, const MultiFileList &file_list, - const vector &global_types, const vector &global_names, + const vector &global_columns, const vector &global_column_ids) { // By default, the multifilereader does not require any global state return nullptr; } -void MultiFileReader::CreateNameMapping(const string &file_name, const vector &local_types, - const vector &local_names, const vector &global_types, - const vector &global_names, - const vector &global_column_ids, MultiFileReaderData &reader_data, - const string &initial_file, - optional_ptr global_state) { - D_ASSERT(global_types.size() == global_names.size()); - D_ASSERT(local_types.size() == local_names.size()); +void MultiFileReader::CreateColumnMappingByName(const string &file_name, + const vector &local_columns, + const vector &global_columns, + const vector &global_column_ids, + MultiFileReaderData &reader_data, + const MultiFileReaderBindData &bind_data, const string &initial_file, + optional_ptr global_state) { + // we have expected types: create a map of name -> column index case_insensitive_map_t name_map; - for (idx_t col_idx = 0; col_idx < local_names.size(); col_idx++) { - name_map[local_names[col_idx]] = col_idx; + for (idx_t col_idx = 0; col_idx < local_columns.size(); col_idx++) { + auto &column = local_columns[col_idx]; + name_map[column.name] = col_idx; } for (idx_t i = 0; i < global_column_ids.size(); i++) { // check if this is a constant column @@ -329,33 +335,40 @@ void MultiFileReader::CreateNameMapping(const string &file_name, const vector= global_types.size()) { + if (global_id >= global_columns.size()) { throw InternalException( - "MultiFileReader::CreatePositionalMapping - global_id is out of range in global_types for this file"); + "MultiFileReader::CreateColumnMappingByName - global_id is out of range in global_types for this file"); } - auto &global_name = global_names[global_id]; - auto entry = name_map.find(global_name); + auto &global_column = global_columns[global_id]; + auto identifier = global_column.GetIdentifierName(); + auto entry = name_map.find(identifier); if (entry == name_map.end()) { - string candidate_names; - for (auto &local_name : local_names) { - if (!candidate_names.empty()) { - candidate_names += ", "; + // identiier not present in file, use default value + if (global_column.default_expression) { + reader_data.constant_map.emplace_back(i, global_column.GetDefaultValue()); + continue; + } else { + string candidate_names; + for (auto &column : local_columns) { + if (!candidate_names.empty()) { + candidate_names += ", "; + } + candidate_names += column.name; } - candidate_names += local_name; + throw IOException(StringUtil::Format( + "Failed to read file \"%s\": schema mismatch in glob: column \"%s\" was read from " + "the original file \"%s\", but could not be found in file \"%s\".\nCandidate names: " + "%s\nIf you are trying to " + "read files with different schemas, try setting union_by_name=True", + file_name, identifier, initial_file, file_name, candidate_names)); } - throw IOException( - StringUtil::Format("Failed to read file \"%s\": schema mismatch in glob: column \"%s\" was read from " - "the original file \"%s\", but could not be found in file \"%s\".\nCandidate names: " - "%s\nIf you are trying to " - "read files with different schemas, try setting union_by_name=True", - file_name, global_name, initial_file, file_name, candidate_names)); } // we found the column in the local file - check if the types are the same auto local_id = entry->second; - D_ASSERT(global_id < global_types.size()); - D_ASSERT(local_id < local_types.size()); - auto &global_type = global_types[global_id]; - auto &local_type = local_types[local_id]; + D_ASSERT(global_id < global_columns.size()); + D_ASSERT(local_id < local_columns.size()); + auto &global_type = global_columns[global_id].type; + auto &local_type = local_columns[local_id].type; ColumnIndex local_index(local_id); if (global_type != local_type) { // the types are not the same - add a cast @@ -372,22 +385,137 @@ void MultiFileReader::CreateNameMapping(const string &file_name, const vector &local_types, - const vector &local_names, const vector &global_types, - const vector &global_names, const vector &global_column_ids, - optional_ptr filters, MultiFileReaderData &reader_data, - const string &initial_file, const MultiFileReaderBindData &options, +void MultiFileReader::CreateColumnMappingByFieldId(const string &file_name, + const vector &local_columns, + const vector &global_columns, + const vector &global_column_ids, + MultiFileReaderData &reader_data, + const MultiFileReaderBindData &bind_data, const string &initial_file, + optional_ptr global_state) { +#ifdef DEBUG + //! Make sure the global columns have field_ids to match on + for (auto &column : global_columns) { + D_ASSERT(!column.identifier.IsNull()); + D_ASSERT(column.identifier.type().id() == LogicalTypeId::INTEGER); + } +#endif + + // we have expected types: create a map of field_id -> column index + unordered_map field_id_map; + for (idx_t col_idx = 0; col_idx < local_columns.size(); col_idx++) { + auto &column = local_columns[col_idx]; + if (column.identifier.IsNull()) { + // Extra columns at the end will not have a field_id + break; + } + auto field_id = column.GetIdentifierFieldId(); + field_id_map[field_id] = col_idx; + } + + // loop through the schema definition + for (idx_t i = 0; i < global_column_ids.size(); i++) { + + // check if this is a constant column + bool constant = false; + for (auto &entry : reader_data.constant_map) { + if (entry.column_id == i) { + constant = true; + break; + } + } + if (constant) { + // this column is constant for this file + continue; + } + + // Handle any generate columns that are not in the schema (currently only file_row_number) + auto &global_idx = global_column_ids[i]; + auto global_id = global_column_ids[i].GetPrimaryIndex(); + if (global_id >= global_columns.size()) { + if (bind_data.file_row_number_idx == global_id) { + reader_data.column_mapping.push_back(i); + // FIXME: this needs a more extensible solution + reader_data.column_ids.push_back(field_id_map.size()); + } else { + throw InternalException("Unexpected generated column"); + } + continue; + } + + const auto &global_column = global_columns[global_id]; + D_ASSERT(!global_column.identifier.IsNull()); + auto it = field_id_map.find(global_column.GetIdentifierFieldId()); + if (it == field_id_map.end()) { + // field id not present in file, use default value + auto &default_val = global_column.default_expression; + D_ASSERT(default_val); + if (default_val->type != ExpressionType::VALUE_CONSTANT) { + throw NotImplementedException("Default expression that isn't constant is not supported yet"); + } + auto &constant_expr = default_val->Cast(); + reader_data.constant_map.emplace_back(i, constant_expr.value); + continue; + } + + const auto &local_id = it->second; + auto &local_column = local_columns[local_id]; + ColumnIndex local_index(local_id); + if (local_column.type != global_column.type) { + // differing types, wrap in a cast column reader + reader_data.cast_map[local_id] = global_column.type; + } else { + local_index = ColumnIndex(local_id, global_idx.GetChildIndexes()); + } + + reader_data.column_mapping.push_back(i); + reader_data.column_ids.push_back(local_id); + reader_data.column_indexes.push_back(std::move(local_index)); + } + reader_data.empty_columns = reader_data.column_ids.empty(); +} + +void MultiFileReader::CreateColumnMapping(const string &file_name, + const vector &local_columns, + const vector &global_columns, + const vector &global_column_ids, + MultiFileReaderData &reader_data, const MultiFileReaderBindData &bind_data, + const string &initial_file, + optional_ptr global_state) { + switch (bind_data.mapping) { + case MultiFileReaderColumnMappingMode::BY_NAME: { + CreateColumnMappingByName(file_name, local_columns, global_columns, global_column_ids, reader_data, bind_data, + initial_file, global_state); + break; + } + case MultiFileReaderColumnMappingMode::BY_FIELD_ID: { + CreateColumnMappingByFieldId(file_name, local_columns, global_columns, global_column_ids, reader_data, + bind_data, initial_file, global_state); + break; + } + default: { + throw InternalException("Unsupported MultiFileReaderColumnMappingMode type"); + } + } +} + +void MultiFileReader::CreateMapping(const string &file_name, + const vector &local_columns, + const vector &global_columns, + const vector &global_column_ids, optional_ptr filters, + MultiFileReaderData &reader_data, const string &initial_file, + const MultiFileReaderBindData &bind_data, optional_ptr global_state) { - CreateNameMapping(file_name, local_types, local_names, global_types, global_names, global_column_ids, reader_data, - initial_file, global_state); - CreateFilterMap(global_types, filters, reader_data, global_state); + // copy global columns and inject any different defaults + CreateColumnMapping(file_name, local_columns, global_columns, global_column_ids, reader_data, bind_data, + initial_file, global_state); + CreateFilterMap(global_columns, filters, reader_data, global_state); } -void MultiFileReader::CreateFilterMap(const vector &global_types, optional_ptr filters, - MultiFileReaderData &reader_data, +void MultiFileReader::CreateFilterMap(const vector &global_columns, + optional_ptr filters, MultiFileReaderData &reader_data, optional_ptr global_state) { if (filters) { - auto filter_map_size = global_types.size(); + auto filter_map_size = global_columns.size(); if (global_state) { filter_map_size += global_state->extra_columns.size(); } diff --git a/src/duckdb/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp b/src/duckdb/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp index c1ab79dfe..29838280e 100644 --- a/src/duckdb/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp +++ b/src/duckdb/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp @@ -77,7 +77,7 @@ StringValueResult::StringValueResult(CSVStates &states, CSVStateMachine &state_m logical_types.emplace_back(LogicalType::VARCHAR); } } - names = csv_file_scan->names; + names = csv_file_scan->GetNames(); if (!csv_file_scan->projected_columns.empty()) { projecting_columns = false; projected_columns = make_unsafe_uniq_array(number_of_columns); @@ -1001,6 +1001,7 @@ void StringValueScanner::Flush(DataChunk &insert_chunk) { // We keep track of the borked lines, in case we are ignoring errors D_ASSERT(csv_file_scan); + auto &names = csv_file_scan->GetNames(); auto &reader_data = csv_file_scan->reader_data; // Now Do the cast-aroo for (idx_t c = 0; c < reader_data.column_ids.size(); c++) { @@ -1059,8 +1060,7 @@ void StringValueScanner::Flush(DataChunk &insert_chunk) { string error_msg = error.str(); SanitizeError(error_msg); auto csv_error = CSVError::CastError( - state_machine->options, csv_file_scan->names[col_idx], error_msg, col_idx, borked_line, - lines_per_batch, + state_machine->options, names[col_idx], error_msg, col_idx, borked_line, lines_per_batch, result.line_positions_per_row[line_error].begin.GetGlobalPosition(result.result_size, first_nl), optional_idx::Invalid(), result_vector.GetType().id(), result.path); error_handler->Error(csv_error); @@ -1089,12 +1089,11 @@ void StringValueScanner::Flush(DataChunk &insert_chunk) { << LogicalTypeIdToString(type.id()) << "\'"; string error_msg = error.str(); SanitizeError(error_msg); - auto csv_error = - CSVError::CastError(state_machine->options, csv_file_scan->names[col_idx], error_msg, - col_idx, borked_line, lines_per_batch, - result.line_positions_per_row[line_error].begin.GetGlobalPosition( - result.result_size, first_nl), - optional_idx::Invalid(), result_vector.GetType().id(), result.path); + auto csv_error = CSVError::CastError( + state_machine->options, names[col_idx], error_msg, col_idx, borked_line, lines_per_batch, + result.line_positions_per_row[line_error].begin.GetGlobalPosition(result.result_size, + first_nl), + optional_idx::Invalid(), result_vector.GetType().id(), result.path); error_handler->Error(csv_error); } } diff --git a/src/duckdb/src/execution/operator/csv_scanner/table_function/csv_file_scanner.cpp b/src/duckdb/src/execution/operator/csv_scanner/table_function/csv_file_scanner.cpp index 093e698d0..ed251cbd0 100644 --- a/src/duckdb/src/execution/operator/csv_scanner/table_function/csv_file_scanner.cpp +++ b/src/duckdb/src/execution/operator/csv_scanner/table_function/csv_file_scanner.cpp @@ -16,31 +16,32 @@ CSVFileScan::CSVFileScan(ClientContext &context, shared_ptr bu error_handler(make_shared_ptr(options_p.ignore_errors.GetValue())), on_disk_file(buffer_manager->file_handle->OnDiskFile()), options(options_p) { + auto global_columns = + MultiFileReaderColumnDefinition::ColumnsFromNamesAndTypes(bind_data.return_names, bind_data.return_types); + auto multi_file_reader = MultiFileReader::CreateDefault("CSV Scan"); if (bind_data.initial_reader.get()) { auto &union_reader = *bind_data.initial_reader; - names = union_reader.GetNames(); + SetNamesAndTypes(union_reader.GetNames(), union_reader.GetTypes()); options = union_reader.options; - types = union_reader.GetTypes(); - multi_file_reader->InitializeReader(*this, options.file_options, bind_data.reader_bind, bind_data.return_types, - bind_data.return_names, column_ids, nullptr, file_path, context, nullptr); + multi_file_reader->InitializeReader(*this, options.file_options, bind_data.reader_bind, global_columns, + column_ids, nullptr, file_path, context, nullptr); InitializeFileNamesTypes(); return; } if (!bind_data.column_info.empty()) { // Serialized Union By name - names = bind_data.column_info[0].names; - types = bind_data.column_info[0].types; - multi_file_reader->InitializeReader(*this, options.file_options, bind_data.reader_bind, bind_data.return_types, - bind_data.return_names, column_ids, nullptr, file_path, context, nullptr); + SetNamesAndTypes(bind_data.column_info[0].names, bind_data.column_info[0].types); + multi_file_reader->InitializeReader(*this, options.file_options, bind_data.reader_bind, global_columns, + column_ids, nullptr, file_path, context, nullptr); InitializeFileNamesTypes(); return; } - names = bind_data.csv_names; - types = bind_data.csv_types; + SetNamesAndTypes(bind_data.csv_names, bind_data.csv_types); + file_schema.Initialize(names, types, file_path); - multi_file_reader->InitializeReader(*this, options.file_options, bind_data.reader_bind, bind_data.return_types, - bind_data.return_names, column_ids, nullptr, file_path, context, nullptr); + multi_file_reader->InitializeReader(*this, options.file_options, bind_data.reader_bind, global_columns, column_ids, + nullptr, file_path, context, nullptr); InitializeFileNamesTypes(); SetStart(); @@ -59,12 +60,22 @@ void CSVFileScan::SetStart() { start_iterator = skip_scanner.GetIterator(); } +void CSVFileScan::SetNamesAndTypes(const vector &names_p, const vector &types_p) { + names = names_p; + types = types_p; + columns = MultiFileReaderColumnDefinition::ColumnsFromNamesAndTypes(names, types); +} + CSVFileScan::CSVFileScan(ClientContext &context, const string &file_path_p, const CSVReaderOptions &options_p, idx_t file_idx_p, const ReadCSVData &bind_data, const vector &column_ids, CSVSchema &file_schema, bool per_file_single_threaded) : file_path(file_path_p), file_idx(file_idx_p), error_handler(make_shared_ptr(options_p.ignore_errors.GetValue())), options(options_p) { auto multi_file_reader = MultiFileReader::CreateDefault("CSV Scan"); + + auto global_columns = + MultiFileReaderColumnDefinition::ColumnsFromNamesAndTypes(bind_data.return_names, bind_data.return_types); + if (file_idx == 0 && bind_data.initial_reader) { auto &union_reader = *bind_data.initial_reader; // Initialize Buffer Manager @@ -72,12 +83,11 @@ CSVFileScan::CSVFileScan(ClientContext &context, const string &file_path_p, cons // Initialize On Disk and Size of file on_disk_file = union_reader.on_disk_file; file_size = union_reader.file_size; - names = union_reader.GetNames(); options = union_reader.options; - types = union_reader.GetTypes(); + SetNamesAndTypes(union_reader.GetNames(), union_reader.GetTypes()); state_machine = union_reader.state_machine; - multi_file_reader->InitializeReader(*this, options.file_options, bind_data.reader_bind, bind_data.return_types, - bind_data.return_names, column_ids, nullptr, file_path, context, nullptr); + multi_file_reader->InitializeReader(*this, options.file_options, bind_data.reader_bind, global_columns, + column_ids, nullptr, file_path, context, nullptr); InitializeFileNamesTypes(); SetStart(); @@ -94,8 +104,7 @@ CSVFileScan::CSVFileScan(ClientContext &context, const string &file_path_p, cons if (file_idx < bind_data.column_info.size()) { // (Serialized) Union By name - names = bind_data.column_info[file_idx].names; - types = bind_data.column_info[file_idx].types; + SetNamesAndTypes(bind_data.column_info[file_idx].names, bind_data.column_info[file_idx].types); if (file_idx < bind_data.union_readers.size()) { // union readers - use cached options D_ASSERT(names == bind_data.union_readers[file_idx]->names); @@ -112,15 +121,14 @@ CSVFileScan::CSVFileScan(ClientContext &context, const string &file_path_p, cons state_machine = make_shared_ptr( state_machine_cache.Get(options.dialect_options.state_machine_options), options); - multi_file_reader->InitializeReader(*this, options.file_options, bind_data.reader_bind, bind_data.return_types, - bind_data.return_names, column_ids, nullptr, file_path, context, nullptr); + multi_file_reader->InitializeReader(*this, options.file_options, bind_data.reader_bind, global_columns, + column_ids, nullptr, file_path, context, nullptr); InitializeFileNamesTypes(); SetStart(); return; } // Sniff it! - names = bind_data.csv_names; - types = bind_data.csv_types; + SetNamesAndTypes(bind_data.csv_names, bind_data.csv_types); if (options.auto_detect && bind_data.files.size() > 1) { if (file_schema.Empty()) { CSVSniffer sniffer(options, buffer_manager, state_machine_cache); @@ -130,8 +138,7 @@ CSVFileScan::CSVFileScan(ClientContext &context, const string &file_path_p, cons options.file_path = file_path; CSVSniffer sniffer(options, buffer_manager, state_machine_cache, false); auto result = sniffer.AdaptiveSniff(file_schema); - names = result.names; - types = result.return_types; + SetNamesAndTypes(result.names, result.return_types); } } if (options.dialect_options.num_cols == 0) { @@ -143,8 +150,8 @@ CSVFileScan::CSVFileScan(ClientContext &context, const string &file_path_p, cons } state_machine = make_shared_ptr( state_machine_cache.Get(options.dialect_options.state_machine_options), options); - multi_file_reader->InitializeReader(*this, options.file_options, bind_data.reader_bind, bind_data.return_types, - bind_data.return_names, column_ids, nullptr, file_path, context, nullptr); + multi_file_reader->InitializeReader(*this, options.file_options, bind_data.reader_bind, global_columns, column_ids, + nullptr, file_path, context, nullptr); InitializeFileNamesTypes(); SetStart(); } @@ -164,8 +171,7 @@ CSVFileScan::CSVFileScan(ClientContext &context, const string &file_name, const CSVSniffer sniffer(options, buffer_manager, state_machine_cache); auto sniffer_result = sniffer.SniffCSV(); if (names.empty()) { - names = sniffer_result.names; - types = sniffer_result.return_types; + SetNamesAndTypes(sniffer_result.names, sniffer_result.return_types); } } if (options.dialect_options.num_cols == 0) { @@ -226,6 +232,10 @@ const vector &CSVFileScan::GetNames() { const vector &CSVFileScan::GetTypes() { return types; } +const vector &CSVFileScan::GetColumns() { + D_ASSERT(types.size() == columns.size()); + return columns; +} void CSVFileScan::InitializeProjection() { for (idx_t i = 0; i < options.dialect_options.num_cols; i++) { diff --git a/src/duckdb/src/execution/operator/csv_scanner/table_function/global_csv_state.cpp b/src/duckdb/src/execution/operator/csv_scanner/table_function/global_csv_state.cpp index b1a4a6165..283a96719 100644 --- a/src/duckdb/src/execution/operator/csv_scanner/table_function/global_csv_state.cpp +++ b/src/duckdb/src/execution/operator/csv_scanner/table_function/global_csv_state.cpp @@ -239,12 +239,16 @@ void FillScanErrorTable(InternalAppender &scan_appender, idx_t scan_idx, idx_t f scan_appender.Append(Value::UINTEGER(NumericCast(options.dialect_options.skip_rows.GetValue()))); // 9. Has Header scan_appender.Append(Value::BOOLEAN(options.dialect_options.header.GetValue())); + + auto &types = file.GetTypes(); + auto &names = file.GetNames(); + // 10. List> {'col1': 'INTEGER', 'col2': 'VARCHAR'} std::ostringstream columns; columns << "{"; - for (idx_t i = 0; i < file.types.size(); i++) { - columns << "'" << file.names[i] << "': '" << file.types[i].ToString() << "'"; - if (i != file.types.size() - 1) { + for (idx_t i = 0; i < types.size(); i++) { + columns << "'" << names[i] << "': '" << types[i].ToString() << "'"; + if (i != types.size() - 1) { columns << ","; } } diff --git a/src/duckdb/src/execution/operator/csv_scanner/util/csv_error.cpp b/src/duckdb/src/execution/operator/csv_scanner/util/csv_error.cpp index f77a93ac0..d4443c173 100644 --- a/src/duckdb/src/execution/operator/csv_scanner/util/csv_error.cpp +++ b/src/duckdb/src/execution/operator/csv_scanner/util/csv_error.cpp @@ -270,8 +270,8 @@ void CSVError::RemoveNewLine(string &error) { error = StringUtil::Split(error, "\n")[0]; } -CSVError CSVError::CastError(const CSVReaderOptions &options, string &column_name, string &cast_error, idx_t column_idx, - string &csv_row, LinesPerBoundary error_info, idx_t row_byte_position, +CSVError CSVError::CastError(const CSVReaderOptions &options, const string &column_name, string &cast_error, + idx_t column_idx, string &csv_row, LinesPerBoundary error_info, idx_t row_byte_position, optional_idx byte_position, LogicalTypeId type, const string ¤t_path) { std::ostringstream error; // Which column diff --git a/src/duckdb/src/function/table/version/pragma_version.cpp b/src/duckdb/src/function/table/version/pragma_version.cpp index de1ba7272..0f4bbf287 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 "4-dev4570" +#define DUCKDB_PATCH_VERSION "4-dev4648" #endif #ifndef DUCKDB_MINOR_VERSION #define DUCKDB_MINOR_VERSION 1 @@ -8,10 +8,10 @@ #define DUCKDB_MAJOR_VERSION 1 #endif #ifndef DUCKDB_VERSION -#define DUCKDB_VERSION "v1.1.4-dev4570" +#define DUCKDB_VERSION "v1.1.4-dev4648" #endif #ifndef DUCKDB_SOURCE_ID -#define DUCKDB_SOURCE_ID "d1740d6cf7" +#define DUCKDB_SOURCE_ID "09cef57892" #endif #include "duckdb/function/table/system_functions.hpp" #include "duckdb/main/database.hpp" diff --git a/src/duckdb/src/include/duckdb/common/enum_util.hpp b/src/duckdb/src/include/duckdb/common/enum_util.hpp index d3ab3ac44..accdea5d4 100644 --- a/src/duckdb/src/include/duckdb/common/enum_util.hpp +++ b/src/duckdb/src/include/duckdb/common/enum_util.hpp @@ -226,6 +226,8 @@ enum class MetaPipelineType : uint8_t; enum class MetricsType : uint8_t; +enum class MultiFileReaderColumnMappingMode : uint8_t; + enum class NType : uint8_t; enum class NewLineIdentifier : uint8_t; @@ -680,6 +682,9 @@ const char* EnumUtil::ToChars(MetaPipelineType value); template<> const char* EnumUtil::ToChars(MetricsType value); +template<> +const char* EnumUtil::ToChars(MultiFileReaderColumnMappingMode value); + template<> const char* EnumUtil::ToChars(NType value); @@ -1215,6 +1220,9 @@ MetaPipelineType EnumUtil::FromString(const char *value); template<> MetricsType EnumUtil::FromString(const char *value); +template<> +MultiFileReaderColumnMappingMode EnumUtil::FromString(const char *value); + template<> NType EnumUtil::FromString(const char *value); diff --git a/src/duckdb/src/include/duckdb/common/multi_file_reader.hpp b/src/duckdb/src/include/duckdb/common/multi_file_reader.hpp index 364f8641c..5778d77ba 100644 --- a/src/duckdb/src/include/duckdb/common/multi_file_reader.hpp +++ b/src/duckdb/src/include/duckdb/common/multi_file_reader.hpp @@ -15,6 +15,7 @@ #include "duckdb/common/optional_ptr.hpp" #include "duckdb/common/types/value.hpp" #include "duckdb/common/union_by_name.hpp" +#include "duckdb/parser/expression/constant_expression.hpp" namespace duckdb { class TableFunction; @@ -35,6 +36,87 @@ struct HivePartitioningIndex { DUCKDB_API static HivePartitioningIndex Deserialize(Deserializer &deserializer); }; +struct MultiFileReaderColumnDefinition { +public: + MultiFileReaderColumnDefinition(const string &name, const LogicalType &type) : name(name), type(type) { + } + + MultiFileReaderColumnDefinition(const MultiFileReaderColumnDefinition &other) + : name(other.name), type(other.type), children(other.children), + default_expression(other.default_expression ? other.default_expression->Copy() : nullptr), + identifier(other.identifier) { + } + + MultiFileReaderColumnDefinition(MultiFileReaderColumnDefinition &&other) noexcept = default; + MultiFileReaderColumnDefinition &operator=(const MultiFileReaderColumnDefinition &other) { + if (this != &other) { + name = other.name; + type = other.type; + children = other.children; + default_expression = other.default_expression ? other.default_expression->Copy() : nullptr; + identifier = other.identifier; + } + return *this; + } + MultiFileReaderColumnDefinition &operator=(MultiFileReaderColumnDefinition &&other) noexcept = default; + +public: + static vector ColumnsFromNamesAndTypes(const vector &names, + const vector &types) { + vector columns; + D_ASSERT(names.size() == types.size()); + for (idx_t i = 0; i < names.size(); i++) { + auto &name = names[i]; + auto &type = types[i]; + columns.emplace_back(name, type); + } + return columns; + } + + static void ExtractNamesAndTypes(const vector &columns, vector &names, + vector &types) { + D_ASSERT(names.empty()); + D_ASSERT(types.empty()); + for (auto &column : columns) { + names.push_back(column.name); + types.push_back(column.type); + } + } + + int32_t GetIdentifierFieldId() const { + D_ASSERT(!identifier.IsNull()); + D_ASSERT(identifier.type().id() == LogicalTypeId::INTEGER); + return identifier.GetValue(); + } + + string GetIdentifierName() const { + if (identifier.IsNull()) { + // No identifier was provided, assume the name as the identifier + return name; + } + D_ASSERT(identifier.type().id() == LogicalTypeId::VARCHAR); + return identifier.GetValue(); + } + + Value GetDefaultValue() const { + D_ASSERT(default_expression); + if (default_expression->type != ExpressionType::VALUE_CONSTANT) { + throw NotImplementedException("Default expression that isn't constant is not supported yet"); + } + auto &constant_expr = default_expression->Cast(); + return constant_expr.value; + } + +public: + string name; + LogicalType type; + vector children; + unique_ptr default_expression; + + //! Either the field_id or the name to map on + Value identifier; +}; + //! The bind data for the multi-file reader, obtained through MultiFileReader::BindReader struct MultiFileReaderBindData { //! The index of the filename column (if any) @@ -43,6 +125,10 @@ struct MultiFileReaderBindData { vector hive_partitioning_indexes; //! The index of the file_row_number column (if any) idx_t file_row_number_idx = DConstants::INVALID_INDEX; + //! (optional) The schema set by the multi file reader + vector schema; + //! The method used to map local -> global columns + MultiFileReaderColumnMappingMode mapping = MultiFileReaderColumnMappingMode::BY_NAME; DUCKDB_API void Serialize(Serializer &serializer) const; DUCKDB_API static MultiFileReaderBindData Deserialize(Deserializer &deserializer); @@ -168,28 +254,28 @@ struct MultiFileReader { DUCKDB_API virtual unique_ptr InitializeGlobalState(ClientContext &context, const MultiFileReaderOptions &file_options, const MultiFileReaderBindData &bind_data, const MultiFileList &file_list, - const vector &global_types, const vector &global_names, + const vector &global_columns, const vector &global_column_ids); //! Finalize the bind phase of the multi-file reader after we know (1) the required (output) columns, and (2) the //! pushed down table filters DUCKDB_API virtual void FinalizeBind(const MultiFileReaderOptions &file_options, const MultiFileReaderBindData &options, const string &filename, - const vector &local_names, const vector &global_types, - const vector &global_names, + const vector &local_columns, + const vector &global_columns, const vector &global_column_ids, MultiFileReaderData &reader_data, ClientContext &context, optional_ptr global_state); //! Create all required mappings from the global types/names to the file-local types/names - DUCKDB_API virtual void CreateMapping(const string &file_name, const vector &local_types, - const vector &local_names, const vector &global_types, - const vector &global_names, + DUCKDB_API virtual void CreateMapping(const string &file_name, + const vector &local_columns, + const vector &global_columns, const vector &global_column_ids, optional_ptr filters, MultiFileReaderData &reader_data, const string &initial_file, const MultiFileReaderBindData &options, optional_ptr global_state); //! Populated the filter_map - DUCKDB_API virtual void CreateFilterMap(const vector &global_types, + DUCKDB_API virtual void CreateFilterMap(const vector &global_columns, optional_ptr filters, MultiFileReaderData &reader_data, optional_ptr global_state); @@ -239,8 +325,11 @@ struct MultiFileReader { } else { shared_ptr reader; reader = make_shared_ptr(context, files.GetFirstFile(), options); - return_types = reader->return_types; - names = reader->names; + auto &columns = reader->GetColumns(); + for (auto &column : columns) { + return_types.emplace_back(column.type); + names.emplace_back(column.name); + } result.Initialize(std::move(reader)); MultiFileReaderBindData bind_data; BindOptions(options.file_options, files, return_types, names, bind_data); @@ -250,14 +339,15 @@ struct MultiFileReader { template void InitializeReader(READER_CLASS &reader, const MultiFileReaderOptions &options, - const MultiFileReaderBindData &bind_data, const vector &global_types, - const vector &global_names, const vector &global_column_ids, - optional_ptr table_filters, const string &initial_file, - ClientContext &context, optional_ptr global_state) { - FinalizeBind(options, bind_data, reader.GetFileName(), reader.GetNames(), global_types, global_names, - global_column_ids, reader.reader_data, context, global_state); - CreateMapping(reader.GetFileName(), reader.GetTypes(), reader.GetNames(), global_types, global_names, - global_column_ids, table_filters, reader.reader_data, initial_file, bind_data, global_state); + const MultiFileReaderBindData &bind_data, + const vector &global_columns, + const vector &global_column_ids, optional_ptr table_filters, + const string &initial_file, ClientContext &context, + optional_ptr global_state) { + FinalizeBind(options, bind_data, reader.GetFileName(), reader.GetColumns(), global_columns, global_column_ids, + reader.reader_data, context, global_state); + CreateMapping(reader.GetFileName(), reader.GetColumns(), global_columns, global_column_ids, table_filters, + reader.reader_data, initial_file, bind_data, global_state); reader.reader_data.filters = table_filters; } @@ -303,11 +393,26 @@ struct MultiFileReader { TableFunctionPartitionInput &input); protected: - virtual void CreateNameMapping(const string &file_name, const vector &local_types, - const vector &local_names, const vector &global_types, - const vector &global_names, const vector &global_column_ids, - MultiFileReaderData &reader_data, const string &initial_file, - optional_ptr global_state); + virtual void CreateColumnMapping(const string &file_name, + const vector &local_columns, + const vector &global_columns, + const vector &global_column_ids, MultiFileReaderData &reader_data, + const MultiFileReaderBindData &bind_data, const string &initial_file, + optional_ptr global_state); + virtual void CreateColumnMappingByFieldId(const string &file_name, + const vector &local_columns, + const vector &global_columns, + const vector &global_column_ids, + MultiFileReaderData &reader_data, + const MultiFileReaderBindData &bind_data, const string &initial_file, + optional_ptr global_state); + virtual void CreateColumnMappingByName(const string &file_name, + const vector &local_columns, + const vector &global_columns, + const vector &global_column_ids, + MultiFileReaderData &reader_data, const MultiFileReaderBindData &bind_data, + const string &initial_file, + optional_ptr global_state); //! Used in errors to report which function is using this MultiFileReader string function_name; diff --git a/src/duckdb/src/include/duckdb/common/multi_file_reader_options.hpp b/src/duckdb/src/include/duckdb/common/multi_file_reader_options.hpp index 99a0297f4..32486cc8f 100644 --- a/src/duckdb/src/include/duckdb/common/multi_file_reader_options.hpp +++ b/src/duckdb/src/include/duckdb/common/multi_file_reader_options.hpp @@ -17,12 +17,16 @@ namespace duckdb { struct BindInfo; class MultiFileList; +enum class MultiFileReaderColumnMappingMode : uint8_t { BY_NAME, BY_FIELD_ID }; + struct MultiFileReaderOptions { bool filename = false; bool hive_partitioning = false; bool auto_detect_hive_partitioning = true; bool union_by_name = false; bool hive_types_autocast = true; + MultiFileReaderColumnMappingMode mapping = MultiFileReaderColumnMappingMode::BY_NAME; + case_insensitive_map_t hive_types_schema; // Default/configurable name of the column containing the file names diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_error.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_error.hpp index a31fd6190..c585576f2 100644 --- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_error.hpp +++ b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_error.hpp @@ -55,7 +55,7 @@ class CSVError { //! Produces error messages for column name -> type mismatch. static CSVError ColumnTypesError(case_insensitive_map_t sql_types_per_column, const vector &names); //! Produces error messages for casting errors - static CSVError CastError(const CSVReaderOptions &options, string &column_name, string &cast_error, + static CSVError CastError(const CSVReaderOptions &options, const string &column_name, string &cast_error, idx_t column_idx, string &csv_row, LinesPerBoundary error_info, idx_t row_byte_position, optional_idx byte_position, LogicalTypeId type, const string ¤t_path); //! Produces error for when the line size exceeds the maximum line size option diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_file_scanner.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_file_scanner.hpp index 3ebc88ff3..016f0b908 100644 --- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_file_scanner.hpp +++ b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/csv_file_scanner.hpp @@ -51,10 +51,15 @@ class CSVFileScan { CSVFileScan(ClientContext &context, const string &file_name, const CSVReaderOptions &options); +public: void SetStart(); + void SetNamesAndTypes(const vector &names, const vector &types); + +public: const string &GetFileName() const; const vector &GetNames(); const vector &GetTypes(); + const vector &GetColumns(); void InitializeProjection(); void Finish(); @@ -96,8 +101,6 @@ class CSVFileScan { //! Whether or not this is an on-disk file bool on_disk_file = true; - vector names; - vector types; MultiFileReaderData reader_data; vector file_types; @@ -110,5 +113,10 @@ class CSVFileScan { CSVReaderOptions options; CSVIterator start_iterator; + +private: + vector names; + vector types; + vector columns; }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/planner/expression/bound_parameter_data.hpp b/src/duckdb/src/include/duckdb/planner/expression/bound_parameter_data.hpp index 181751c1e..0467e37c5 100644 --- a/src/duckdb/src/include/duckdb/planner/expression/bound_parameter_data.hpp +++ b/src/duckdb/src/include/duckdb/planner/expression/bound_parameter_data.hpp @@ -17,7 +17,7 @@ struct BoundParameterData { public: BoundParameterData() { } - explicit BoundParameterData(Value val) : value(std::move(val)), return_type(value.type()) { + explicit BoundParameterData(Value val) : value(std::move(val)), return_type(GetDefaultType(value.type())) { } BoundParameterData(Value val, LogicalType type_p) : value(std::move(val)), return_type(std::move(type_p)) { } @@ -39,6 +39,14 @@ struct BoundParameterData { void Serialize(Serializer &serializer) const; static shared_ptr Deserialize(Deserializer &deserializer); + +private: + LogicalType GetDefaultType(const LogicalType &type) { + if (value.type().id() == LogicalTypeId::VARCHAR && StringType::GetCollation(type).empty()) { + return LogicalTypeId::STRING_LITERAL; + } + return value.type(); + } }; } // namespace duckdb diff --git a/src/duckdb/src/planner/binder/expression/bind_comparison_expression.cpp b/src/duckdb/src/planner/binder/expression/bind_comparison_expression.cpp index cd490f433..525dd3c62 100644 --- a/src/duckdb/src/planner/binder/expression/bind_comparison_expression.cpp +++ b/src/duckdb/src/planner/binder/expression/bind_comparison_expression.cpp @@ -28,6 +28,7 @@ void ExpressionBinder::TestCollation(ClientContext &context, const string &colla static bool SwitchVarcharComparison(const LogicalType &type) { switch (type.id()) { + case LogicalTypeId::BOOLEAN: case LogicalTypeId::TINYINT: case LogicalTypeId::SMALLINT: case LogicalTypeId::INTEGER: diff --git a/src/duckdb/src/planner/binder/statement/bind_execute.cpp b/src/duckdb/src/planner/binder/statement/bind_execute.cpp index 3e3af4d6a..86799dc95 100644 --- a/src/duckdb/src/planner/binder/statement/bind_execute.cpp +++ b/src/duckdb/src/planner/binder/statement/bind_execute.cpp @@ -54,7 +54,8 @@ BoundStatement Binder::Bind(ExecuteStatement &stmt) { parameter_data = BoundParameterData(std::move(constant.value), std::move(return_type)); } else { auto value = ExpressionExecutor::EvaluateScalar(context, *bound_expr, true); - parameter_data = BoundParameterData(std::move(value)); + auto value_type = value.type(); + parameter_data = BoundParameterData(std::move(value), std::move(value_type)); } bind_values[pair.first] = std::move(parameter_data); } diff --git a/src/duckdb/third_party/httplib/httplib.hpp b/src/duckdb/third_party/httplib/httplib.hpp index 6432d5d1a..f06db896a 100644 --- a/src/duckdb/third_party/httplib/httplib.hpp +++ b/src/duckdb/third_party/httplib/httplib.hpp @@ -2466,7 +2466,6 @@ inline std::string encode_url(const std::string &s) { for (size_t i = 0; s[i]; i++) { switch (s[i]) { case ' ': result += "%20"; break; - case '+': result += "%2B"; break; case '\r': result += "%0D"; break; case '\n': result += "%0A"; break; case '\'': result += "%27"; break; From 44e807a0efec676989bef1ade350d0779519477b Mon Sep 17 00:00:00 2001 From: DuckDB Labs GitHub Bot Date: Fri, 17 Jan 2025 00:32:52 +0000 Subject: [PATCH 15/16] Update vendored DuckDB sources to 9d02a507 --- .../extension/parquet/parquet_reader.cpp | 5 +- .../src/common/arrow/arrow_converter.cpp | 1 + .../types/column/column_data_allocator.cpp | 5 - .../common/types/row/tuple_data_segment.cpp | 4 - .../operator/join/physical_hash_join.cpp | 1 - .../execution/radix_partitioned_hashtable.cpp | 4 +- src/duckdb/src/function/table/table_scan.cpp | 144 ++++++++++++++---- .../function/table/version/pragma_version.cpp | 6 +- .../duckdb/planner/filter/constant_filter.hpp | 1 + .../duckdb/planner/filter/in_filter.hpp | 2 - .../duckdb/planner/filter/optional_filter.hpp | 8 +- .../include/duckdb/storage/storage_info.hpp | 4 +- .../src/planner/filter/conjunction_filter.cpp | 1 + .../src/planner/filter/constant_filter.cpp | 21 +++ src/duckdb/src/planner/filter/in_filter.cpp | 11 +- .../compression/dictionary/decompression.cpp | 8 +- .../storage/compression/roaring/common.cpp | 4 + .../compression/validity_uncompressed.cpp | 4 + .../src/storage/single_file_block_manager.cpp | 29 ++-- src/duckdb/src/storage/storage_info.cpp | 6 + 20 files changed, 191 insertions(+), 78 deletions(-) diff --git a/src/duckdb/extension/parquet/parquet_reader.cpp b/src/duckdb/extension/parquet/parquet_reader.cpp index 561386773..6c5fd8f71 100644 --- a/src/duckdb/extension/parquet/parquet_reader.cpp +++ b/src/duckdb/extension/parquet/parquet_reader.cpp @@ -778,12 +778,13 @@ void ParquetReader::PrepareRowGroupBuffer(ParquetReaderScanState &state, idx_t c FilterPropagateResult prune_result; // TODO we might not have stats but STILL a bloom filter so move this up // check the bloom filter if present - if (!column_reader.Type().IsNested() && + bool is_generated_column = column_reader.FileIdx() >= group.columns.size(); + if (!column_reader.Type().IsNested() && !is_generated_column && ParquetStatisticsUtils::BloomFilterSupported(column_reader.Type().id()) && ParquetStatisticsUtils::BloomFilterExcludes(filter, group.columns[column_reader.FileIdx()].meta_data, *state.thrift_file_proto, allocator)) { prune_result = FilterPropagateResult::FILTER_ALWAYS_FALSE; - } else if (column_reader.Type().id() == LogicalTypeId::VARCHAR && + } else if (column_reader.Type().id() == LogicalTypeId::VARCHAR && !is_generated_column && group.columns[column_reader.FileIdx()].meta_data.statistics.__isset.min_value && group.columns[column_reader.FileIdx()].meta_data.statistics.__isset.max_value) { diff --git a/src/duckdb/src/common/arrow/arrow_converter.cpp b/src/duckdb/src/common/arrow/arrow_converter.cpp index a693034a9..c4ad7b01c 100644 --- a/src/duckdb/src/common/arrow/arrow_converter.cpp +++ b/src/duckdb/src/common/arrow/arrow_converter.cpp @@ -73,6 +73,7 @@ void SetArrowMapFormat(DuckDBArrowSchemaHolder &root_holder, ArrowSchema &child, InitializeChild(root_holder.nested_children.back()[0], root_holder); child.children = &root_holder.nested_children_ptr.back()[0]; child.children[0]->name = "entries"; + child.children[0]->flags = 0; // Set the 'entries' field to non-nullable SetArrowFormat(root_holder, **child.children, ListType::GetChildType(type), options, context); } diff --git a/src/duckdb/src/common/types/column/column_data_allocator.cpp b/src/duckdb/src/common/types/column/column_data_allocator.cpp index 66a1e612f..aa14d6ae2 100644 --- a/src/duckdb/src/common/types/column/column_data_allocator.cpp +++ b/src/duckdb/src/common/types/column/column_data_allocator.cpp @@ -54,12 +54,7 @@ ColumnDataAllocator::~ColumnDataAllocator() { for (auto &block : blocks) { block.handle->SetDestroyBufferUpon(DestroyBufferUpon::UNPIN); } - const auto data_size = SizeInBytes(); blocks.clear(); - if (Allocator::SupportsFlush() && - data_size > alloc.buffer_manager->GetBufferPool().GetAllocatorBulkDeallocationFlushThreshold()) { - Allocator::FlushAll(); - } } BufferHandle ColumnDataAllocator::Pin(uint32_t block_id) { diff --git a/src/duckdb/src/common/types/row/tuple_data_segment.cpp b/src/duckdb/src/common/types/row/tuple_data_segment.cpp index ddec13238..d14c0e0ba 100644 --- a/src/duckdb/src/common/types/row/tuple_data_segment.cpp +++ b/src/duckdb/src/common/types/row/tuple_data_segment.cpp @@ -119,10 +119,6 @@ TupleDataSegment::~TupleDataSegment() { } pinned_row_handles.clear(); pinned_heap_handles.clear(); - if (Allocator::SupportsFlush() && allocator && - data_size > allocator->GetBufferManager().GetBufferPool().GetAllocatorBulkDeallocationFlushThreshold()) { - Allocator::FlushAll(); - } allocator.reset(); } 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 3c01a4acf..a66cb8cc6 100644 --- a/src/duckdb/src/execution/operator/join/physical_hash_join.cpp +++ b/src/duckdb/src/execution/operator/join/physical_hash_join.cpp @@ -638,7 +638,6 @@ void JoinFilterPushdownInfo::PushInFilter(const JoinFilterPushdownFilter &info, // generate the OR filter auto in_filter = make_uniq(std::move(in_list)); - in_filter->origin_is_hash_join = true; // we push the OR filter as an OptionalFilter so that we can use it for zonemap pruning only // the IN-list is expensive to execute otherwise diff --git a/src/duckdb/src/execution/radix_partitioned_hashtable.cpp b/src/duckdb/src/execution/radix_partitioned_hashtable.cpp index cf6038fa4..75843135d 100644 --- a/src/duckdb/src/execution/radix_partitioned_hashtable.cpp +++ b/src/duckdb/src/execution/radix_partitioned_hashtable.cpp @@ -281,12 +281,12 @@ idx_t RadixHTConfig::GetRadixBits() const { } void RadixHTConfig::SetRadixBitsInternal(const idx_t radix_bits_p, bool external) { - if (sink_radix_bits >= radix_bits_p || sink.any_combined) { + if (sink_radix_bits > radix_bits_p || sink.any_combined) { return; } auto guard = sink.Lock(); - if (sink_radix_bits >= radix_bits_p || sink.any_combined) { + if (sink_radix_bits > radix_bits_p || sink.any_combined) { return; } diff --git a/src/duckdb/src/function/table/table_scan.cpp b/src/duckdb/src/function/table/table_scan.cpp index 1b67d3b9b..8561438d2 100644 --- a/src/duckdb/src/function/table/table_scan.cpp +++ b/src/duckdb/src/function/table/table_scan.cpp @@ -24,6 +24,7 @@ #include "duckdb/planner/expression/bound_constant_expression.hpp" #include "duckdb/planner/expression/bound_comparison_expression.hpp" #include "duckdb/planner/filter/conjunction_filter.hpp" +#include "duckdb/common/types/value_map.hpp" namespace duckdb { @@ -361,56 +362,137 @@ unique_ptr DuckIndexScanInitGlobal(ClientContext &cont return std::move(g_state); } -void ExtractInFilter(unique_ptr &filter, BoundColumnRefExpression &bound_ref, - unique_ptr>> &filter_expressions) { - // Special-handling of IN filters. - // They are part of a CONJUNCTION_AND. - if (filter->filter_type != TableFilterType::CONJUNCTION_AND) { - return; +void ExtractExpressionsFromValues(value_set_t &unique_values, BoundColumnRefExpression &bound_ref, + vector> &expressions) { + for (const auto &value : unique_values) { + auto bound_constant = make_uniq(value); + auto filter_expr = make_uniq(ExpressionType::COMPARE_EQUAL, bound_ref.Copy(), + std::move(bound_constant)); + expressions.push_back(std::move(filter_expr)); } +} - auto &and_filter = filter->Cast(); - auto &children = and_filter.child_filters; - if (children.empty()) { - return; +void ExtractIn(InFilter &filter, BoundColumnRefExpression &bound_ref, vector> &expressions) { + // Eliminate any duplicates. + value_set_t unique_values; + for (const auto &value : filter.values) { + if (unique_values.find(value) == unique_values.end()) { + unique_values.insert(value); + } } - if (children[0]->filter_type != TableFilterType::OPTIONAL_FILTER) { + ExtractExpressionsFromValues(unique_values, bound_ref, expressions); +} + +void ExtractConjunctionAnd(ConjunctionAndFilter &filter, BoundColumnRefExpression &bound_ref, + vector> &expressions) { + if (filter.child_filters.empty()) { return; } - auto &optional_filter = children[0]->Cast(); - auto &child = optional_filter.child_filter; - if (child->filter_type != TableFilterType::IN_FILTER) { + // Extract the CONSTANT_COMPARISON and IN_FILTER children. + vector> comparisons; + vector> in_filters; + + for (idx_t i = 0; i < filter.child_filters.size(); i++) { + if (filter.child_filters[i]->filter_type == TableFilterType::CONSTANT_COMPARISON) { + auto &comparison = filter.child_filters[i]->Cast(); + comparisons.push_back(comparison); + continue; + } + + if (filter.child_filters[i]->filter_type == TableFilterType::OPTIONAL_FILTER) { + auto &optional_filter = filter.child_filters[i]->Cast(); + if (!optional_filter.child_filter) { + return; + } + if (optional_filter.child_filter->filter_type != TableFilterType::IN_FILTER) { + // No support for other optional filter types yet. + return; + } + auto &in_filter = optional_filter.child_filter->Cast(); + in_filters.push_back(in_filter); + continue; + } + + // No support for other filter types than CONSTANT_COMPARISON and IN_FILTER in CONJUNCTION_AND yet. return; } - auto &in_filter = child->Cast(); - if (!in_filter.origin_is_hash_join) { + // No support for other CONJUNCTION_AND cases yet. + if (in_filters.empty()) { return; } - // They are all on the same column, so we can split them. - for (const auto &value : in_filter.values) { - auto bound_constant = make_uniq(value); - auto filter_expr = make_uniq(ExpressionType::COMPARE_EQUAL, bound_ref.Copy(), - std::move(bound_constant)); - filter_expressions->push_back(std::move(filter_expr)); + // Get the combined unique values of the IN filters. + value_set_t unique_values; + for (idx_t filter_idx = 0; filter_idx < in_filters.size(); filter_idx++) { + auto &in_filter = in_filters[filter_idx].get(); + for (idx_t value_idx = 0; value_idx < in_filter.values.size(); value_idx++) { + auto &value = in_filter.values[value_idx]; + if (unique_values.find(value) != unique_values.end()) { + continue; + } + unique_values.insert(value); + } + } + + // Extract all qualifying values. + for (auto value_it = unique_values.begin(); value_it != unique_values.end();) { + bool qualifies = true; + for (idx_t comp_idx = 0; comp_idx < comparisons.size(); comp_idx++) { + if (!comparisons[comp_idx].get().Compare(*value_it)) { + qualifies = false; + value_it = unique_values.erase(value_it); + break; + } + } + if (qualifies) { + value_it++; + } + } + + ExtractExpressionsFromValues(unique_values, bound_ref, expressions); +} + +void ExtractFilter(TableFilter &filter, BoundColumnRefExpression &bound_ref, + vector> &expressions) { + switch (filter.filter_type) { + case TableFilterType::OPTIONAL_FILTER: { + auto &optional_filter = filter.Cast(); + if (!optional_filter.child_filter) { + return; + } + return ExtractFilter(*optional_filter.child_filter, bound_ref, expressions); + } + case TableFilterType::IN_FILTER: { + auto &in_filter = filter.Cast(); + ExtractIn(in_filter, bound_ref, expressions); + return; + } + case TableFilterType::CONJUNCTION_AND: { + auto &conjunction_and = filter.Cast(); + ExtractConjunctionAnd(conjunction_and, bound_ref, expressions); + return; + } + default: + return; } } -unique_ptr>> ExtractFilters(const ColumnDefinition &col, unique_ptr &filter, - idx_t storage_idx) { +vector> ExtractFilterExpressions(const ColumnDefinition &col, unique_ptr &filter, + idx_t storage_idx) { ColumnBinding binding(0, storage_idx); auto bound_ref = make_uniq(col.Name(), col.Type(), binding); - auto filter_expressions = make_uniq>>(); - ExtractInFilter(filter, *bound_ref, filter_expressions); + vector> expressions; + ExtractFilter(*filter, *bound_ref, expressions); - if (filter_expressions->empty()) { + // Attempt matching the top-level filter to the index expression. + if (expressions.empty()) { auto filter_expr = filter->ToExpression(*bound_ref); - filter_expressions->push_back(std::move(filter_expr)); + expressions.push_back(std::move(filter_expr)); } - return filter_expressions; + return expressions; } bool TryScanIndex(ART &art, const ColumnList &column_list, TableFunctionInitInput &input, TableFilterSet &filter_set, @@ -453,8 +535,8 @@ bool TryScanIndex(ART &art, const ColumnList &column_list, TableFunctionInitInpu return false; } - auto filter_expressions = ExtractFilters(col, filter->second, storage_index.GetIndex()); - for (const auto &filter_expr : *filter_expressions) { + auto expressions = ExtractFilterExpressions(col, filter->second, storage_index.GetIndex()); + for (const auto &filter_expr : expressions) { auto scan_state = art.TryInitializeScan(*index_expr, *filter_expr); if (!scan_state) { return false; diff --git a/src/duckdb/src/function/table/version/pragma_version.cpp b/src/duckdb/src/function/table/version/pragma_version.cpp index 0f4bbf287..2ba223d9f 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 "4-dev4648" +#define DUCKDB_PATCH_VERSION "4-dev4679" #endif #ifndef DUCKDB_MINOR_VERSION #define DUCKDB_MINOR_VERSION 1 @@ -8,10 +8,10 @@ #define DUCKDB_MAJOR_VERSION 1 #endif #ifndef DUCKDB_VERSION -#define DUCKDB_VERSION "v1.1.4-dev4648" +#define DUCKDB_VERSION "v1.1.4-dev4679" #endif #ifndef DUCKDB_SOURCE_ID -#define DUCKDB_SOURCE_ID "09cef57892" +#define DUCKDB_SOURCE_ID "0024e5d4be" #endif #include "duckdb/function/table/system_functions.hpp" #include "duckdb/main/database.hpp" diff --git a/src/duckdb/src/include/duckdb/planner/filter/constant_filter.hpp b/src/duckdb/src/include/duckdb/planner/filter/constant_filter.hpp index 613821859..25d516a5c 100644 --- a/src/duckdb/src/include/duckdb/planner/filter/constant_filter.hpp +++ b/src/duckdb/src/include/duckdb/planner/filter/constant_filter.hpp @@ -27,6 +27,7 @@ class ConstantFilter : public TableFilter { Value constant; public: + bool Compare(const Value &value) const; FilterPropagateResult CheckStatistics(BaseStatistics &stats) override; string ToString(const string &column_name) override; bool Equals(const TableFilter &other) const override; diff --git a/src/duckdb/src/include/duckdb/planner/filter/in_filter.hpp b/src/duckdb/src/include/duckdb/planner/filter/in_filter.hpp index 19e3862a3..c9028ed5e 100644 --- a/src/duckdb/src/include/duckdb/planner/filter/in_filter.hpp +++ b/src/duckdb/src/include/duckdb/planner/filter/in_filter.hpp @@ -19,10 +19,8 @@ class InFilter : public TableFilter { public: explicit InFilter(vector values); - InFilter(vector values, bool origin_is_hash_join); vector values; - bool origin_is_hash_join; public: FilterPropagateResult CheckStatistics(BaseStatistics &stats) override; diff --git a/src/duckdb/src/include/duckdb/planner/filter/optional_filter.hpp b/src/duckdb/src/include/duckdb/planner/filter/optional_filter.hpp index d694674d8..edbd060ae 100644 --- a/src/duckdb/src/include/duckdb/planner/filter/optional_filter.hpp +++ b/src/duckdb/src/include/duckdb/planner/filter/optional_filter.hpp @@ -20,16 +20,16 @@ class OptionalFilter : public TableFilter { public: explicit OptionalFilter(unique_ptr filter = nullptr); + //! Optional child filters. + unique_ptr child_filter; + +public: string ToString(const string &column_name) override; unique_ptr Copy() const override; unique_ptr ToExpression(const Expression &column) const override; FilterPropagateResult CheckStatistics(BaseStatistics &stats) override; void Serialize(Serializer &serializer) const override; static unique_ptr Deserialize(Deserializer &deserializer); - -public: - // optional child filters - unique_ptr child_filter; }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/storage/storage_info.hpp b/src/duckdb/src/include/duckdb/storage/storage_info.hpp index a2047d720..be36b69c5 100644 --- a/src/duckdb/src/include/duckdb/storage/storage_info.hpp +++ b/src/duckdb/src/include/duckdb/storage/storage_info.hpp @@ -54,8 +54,10 @@ struct Storage { static void VerifyBlockAllocSize(const idx_t block_alloc_size); }; -//! The version number of the database storage format +//! The version number default, lower and upper bounds of the database storage format extern const uint64_t VERSION_NUMBER; +extern const uint64_t VERSION_NUMBER_LOWER; +extern const uint64_t VERSION_NUMBER_UPPER; string GetDuckDBVersion(idx_t version_number); optional_idx GetStorageVersion(const char *version_string); optional_idx GetSerializationVersion(const char *version_string); diff --git a/src/duckdb/src/planner/filter/conjunction_filter.cpp b/src/duckdb/src/planner/filter/conjunction_filter.cpp index abb53b4aa..aa11de721 100644 --- a/src/duckdb/src/planner/filter/conjunction_filter.cpp +++ b/src/duckdb/src/planner/filter/conjunction_filter.cpp @@ -1,4 +1,5 @@ #include "duckdb/planner/filter/conjunction_filter.hpp" + #include "duckdb/planner/expression/bound_conjunction_expression.hpp" namespace duckdb { diff --git a/src/duckdb/src/planner/filter/constant_filter.cpp b/src/duckdb/src/planner/filter/constant_filter.cpp index 9384cd204..99dc10a4e 100644 --- a/src/duckdb/src/planner/filter/constant_filter.cpp +++ b/src/duckdb/src/planner/filter/constant_filter.cpp @@ -2,6 +2,8 @@ #include "duckdb/storage/statistics/base_statistics.hpp" #include "duckdb/planner/expression/bound_comparison_expression.hpp" #include "duckdb/planner/expression/bound_constant_expression.hpp" +#include "duckdb/common/value_operations/value_operations.hpp" +#include "duckdb/common/enum_util.hpp" namespace duckdb { @@ -13,6 +15,25 @@ ConstantFilter::ConstantFilter(ExpressionType comparison_type_p, Value constant_ } } +bool ConstantFilter::Compare(const Value &value) const { + switch (comparison_type) { + case ExpressionType::COMPARE_EQUAL: + return ValueOperations::Equals(value, constant); + case ExpressionType::COMPARE_NOTEQUAL: + return ValueOperations::NotEquals(value, constant); + case ExpressionType::COMPARE_GREATERTHAN: + return ValueOperations::GreaterThan(value, constant); + case ExpressionType::COMPARE_GREATERTHANOREQUALTO: + return ValueOperations::GreaterThanEquals(value, constant); + case ExpressionType::COMPARE_LESSTHAN: + return ValueOperations::LessThan(value, constant); + case ExpressionType::COMPARE_LESSTHANOREQUALTO: + return ValueOperations::LessThanEquals(value, constant); + default: + throw InternalException("unknown comparison type for ConstantFilter: " + EnumUtil::ToString(comparison_type)); + } +} + FilterPropagateResult ConstantFilter::CheckStatistics(BaseStatistics &stats) { if (!stats.CanHaveNoNull()) { // no non-null values are possible: always false diff --git a/src/duckdb/src/planner/filter/in_filter.cpp b/src/duckdb/src/planner/filter/in_filter.cpp index b3eff6e23..22c7f83cf 100644 --- a/src/duckdb/src/planner/filter/in_filter.cpp +++ b/src/duckdb/src/planner/filter/in_filter.cpp @@ -1,15 +1,12 @@ #include "duckdb/planner/filter/in_filter.hpp" + #include "duckdb/storage/statistics/base_statistics.hpp" #include "duckdb/planner/expression/bound_constant_expression.hpp" #include "duckdb/planner/expression/bound_operator_expression.hpp" namespace duckdb { -InFilter::InFilter(vector values_p) : InFilter(std::move(values_p), false) { -} - -InFilter::InFilter(vector values_p, bool origin_is_hash_join) - : TableFilter(TableFilterType::IN_FILTER), values(std::move(values_p)), origin_is_hash_join(origin_is_hash_join) { +InFilter::InFilter(vector values_p) : TableFilter(TableFilterType::IN_FILTER), values(std::move(values_p)) { for (auto &val : values) { if (val.IsNull()) { throw InternalException("InFilter constant cannot be NULL - use IsNullFilter instead"); @@ -74,11 +71,11 @@ bool InFilter::Equals(const TableFilter &other_p) const { return false; } auto &other = other_p.Cast(); - return other.values == values && other.origin_is_hash_join == origin_is_hash_join; + return other.values == values; } unique_ptr InFilter::Copy() const { - return make_uniq(values, origin_is_hash_join); + return make_uniq(values); } } // namespace duckdb diff --git a/src/duckdb/src/storage/compression/dictionary/decompression.cpp b/src/duckdb/src/storage/compression/dictionary/decompression.cpp index a81c0e122..db0ff6c09 100644 --- a/src/duckdb/src/storage/compression/dictionary/decompression.cpp +++ b/src/duckdb/src/storage/compression/dictionary/decompression.cpp @@ -43,16 +43,16 @@ void CompressedStringScanState::Initialize(ColumnSegment &segment, bool initiali block_size = segment.GetBlockManager().GetBlockSize(); dict = DictionaryCompression::GetDictionary(segment, *handle); - dictionary = make_buffer(segment.type, index_buffer_count); - dictionary_size = index_buffer_count; - if (!initialize_dictionary) { // Used by fetch, as fetch will never produce a DictionaryVector return; } + dictionary = make_buffer(segment.type, index_buffer_count); + dictionary_size = index_buffer_count; auto dict_child_data = FlatVector::GetData(*(dictionary)); - for (uint32_t i = 0; i < index_buffer_count; i++) { + FlatVector::SetNull(*dictionary, 0, true); + for (uint32_t i = 1; i < index_buffer_count; i++) { // NOTE: the passing of dict_child_vector, will not be used, its for big strings uint16_t str_len = GetStringLength(i); dict_child_data[i] = FetchStringFromDict(UnsafeNumericCast(index_buffer_ptr[i]), str_len); diff --git a/src/duckdb/src/storage/compression/roaring/common.cpp b/src/duckdb/src/storage/compression/roaring/common.cpp index e5dad7503..e4fd5f714 100644 --- a/src/duckdb/src/storage/compression/roaring/common.cpp +++ b/src/duckdb/src/storage/compression/roaring/common.cpp @@ -220,6 +220,10 @@ void RoaringScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t sc } void RoaringScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result) { + if (result.GetVectorType() == VectorType::DICTIONARY_VECTOR) { + // dictionary encoding handles the validity itself + return; + } RoaringScanPartial(segment, state, scan_count, result, 0); } diff --git a/src/duckdb/src/storage/compression/validity_uncompressed.cpp b/src/duckdb/src/storage/compression/validity_uncompressed.cpp index 8fa4acca9..48f2ec749 100644 --- a/src/duckdb/src/storage/compression/validity_uncompressed.cpp +++ b/src/duckdb/src/storage/compression/validity_uncompressed.cpp @@ -401,6 +401,10 @@ void ValidityScanPartial(ColumnSegment &segment, ColumnScanState &state, idx_t s } void ValidityScan(ColumnSegment &segment, ColumnScanState &state, idx_t scan_count, Vector &result) { + if (result.GetVectorType() == VectorType::DICTIONARY_VECTOR) { + // dictionary encoding handles the validity itself + return; + } result.Flatten(scan_count); auto start = segment.GetRelativeIndex(state.row_index); diff --git a/src/duckdb/src/storage/single_file_block_manager.cpp b/src/duckdb/src/storage/single_file_block_manager.cpp index 2b63fa247..f00d93040 100644 --- a/src/duckdb/src/storage/single_file_block_manager.cpp +++ b/src/duckdb/src/storage/single_file_block_manager.cpp @@ -4,6 +4,7 @@ #include "duckdb/common/checksum.hpp" #include "duckdb/common/exception.hpp" #include "duckdb/common/serializer/memory_stream.hpp" +#include "duckdb/main/attached_database.hpp" #include "duckdb/main/config.hpp" #include "duckdb/main/database.hpp" #include "duckdb/storage/buffer_manager.hpp" @@ -59,27 +60,25 @@ MainHeader MainHeader::Read(ReadStream &source) { } header.version_number = source.Read(); // check the version number - if (header.version_number != VERSION_NUMBER) { + if (header.version_number < VERSION_NUMBER_LOWER || header.version_number > VERSION_NUMBER_UPPER) { auto version = GetDuckDBVersion(header.version_number); string version_text; if (!version.empty()) { // known version version_text = "DuckDB version " + string(version); } else { - version_text = string("an ") + (VERSION_NUMBER > header.version_number ? "older development" : "newer") + + version_text = string("an ") + + (VERSION_NUMBER_UPPER > header.version_number ? "older development" : "newer") + string(" version of DuckDB"); } throw IOException( - "Trying to read a database file with version number %lld, but we can only read version %lld.\n" + "Trying to read a database file with version number %lld, but we can only read versions between %lld and " + "%lld.\n" "The database file was created with %s.\n\n" - "The storage of DuckDB is not yet stable; newer versions of DuckDB cannot read old database files and " - "vice versa.\n" - "The storage will be stabilized when version 1.0 releases.\n\n" - "For now, we recommend that you load the database file in a supported version of DuckDB, and use the " - "EXPORT DATABASE command " - "followed by IMPORT DATABASE on the current version of DuckDB.\n\n" - "See the storage page for more information: https://duckdb.org/internals/storage", - header.version_number, VERSION_NUMBER, version_text); + "Newer DuckDB version might introduce backward incompatible changes (possibly guarded by compatibility " + "settings)" + "See the storage page for migration strategy and more informations: https://duckdb.org/internals/storage", + header.version_number, VERSION_NUMBER_LOWER, VERSION_NUMBER_UPPER, version_text); } // read the flags for (idx_t i = 0; i < FLAG_COUNT; i++) { @@ -166,6 +165,10 @@ FileOpenFlags SingleFileBlockManager::GetFileFlags(bool create_new) const { return result; } +static void AddStorageVersion(AttachedDatabase &db, const uint64_t version) { + db.tags["storage_version"] = std::to_string(version); +} + void SingleFileBlockManager::CreateNewDatabase() { auto flags = GetFileFlags(true); @@ -180,6 +183,7 @@ void SingleFileBlockManager::CreateNewDatabase() { MainHeader main_header; main_header.version_number = VERSION_NUMBER; memset(main_header.flags, 0, sizeof(uint64_t) * MainHeader::FLAG_COUNT); + AddStorageVersion(db, main_header.version_number); SerializeHeaderStructure(main_header, header_buffer.buffer); // now write the header to the file @@ -235,7 +239,8 @@ void SingleFileBlockManager::LoadExistingDatabase() { MainHeader::CheckMagicBytes(*handle); // otherwise, we check the metadata of the file ReadAndChecksum(header_buffer, 0); - DeserializeHeaderStructure(header_buffer.buffer); + MainHeader main_header = DeserializeHeaderStructure(header_buffer.buffer); + AddStorageVersion(db, main_header.version_number); // read the database headers from disk DatabaseHeader h1; diff --git a/src/duckdb/src/storage/storage_info.cpp b/src/duckdb/src/storage/storage_info.cpp index b814fdc34..a2700df9c 100644 --- a/src/duckdb/src/storage/storage_info.cpp +++ b/src/duckdb/src/storage/storage_info.cpp @@ -6,6 +6,11 @@ namespace duckdb { const uint64_t VERSION_NUMBER = 64; +const uint64_t VERSION_NUMBER_LOWER = 64; +const uint64_t VERSION_NUMBER_UPPER = 65; + +static_assert(VERSION_NUMBER_LOWER <= VERSION_NUMBER, "Check on VERSION_NUMBER lower bound"); +static_assert(VERSION_NUMBER <= VERSION_NUMBER_UPPER, "Check on VERSION_NUMBER upper bound"); struct StorageVersionInfo { const char *version_name; @@ -71,6 +76,7 @@ static const StorageVersionInfo storage_version_info[] = { {"v1.1.1", 64}, {"v1.1.2", 64}, {"v1.1.3", 64}, + {"v1.2.0", 65}, {nullptr, 0} }; // END OF STORAGE VERSION INFO From e7008ef776542d83b2d72bbbb4e8dd5029f3212f Mon Sep 17 00:00:00 2001 From: DuckDB Labs GitHub Bot Date: Sat, 18 Jan 2025 00:31:56 +0000 Subject: [PATCH 16/16] Update vendored DuckDB sources to 44e807a0 --- .../src/common/arrow/arrow_type_extension.cpp | 11 +- .../src/common/arrow/schema_metadata.cpp | 2 +- src/duckdb/src/common/enum_util.cpp | 9 +- .../csv_scanner/sniffer/header_detection.cpp | 2 +- .../csv_scanner/sniffer/type_detection.cpp | 4 + .../operator/persistent/physical_delete.cpp | 65 ++++++-- .../operator/persistent/physical_insert.cpp | 63 ++++++-- .../src/function/compression_config.cpp | 4 + .../table/arrow/arrow_duck_schema.cpp | 10 +- src/duckdb/src/function/table/read_csv.cpp | 20 ++- src/duckdb/src/function/table/sniff_csv.cpp | 7 + .../table/system/duckdb_secret_types.cpp | 71 +++++++++ .../src/function/table/system_functions.cpp | 1 + .../function/table/version/pragma_version.cpp | 6 +- .../window/window_aggregate_function.cpp | 7 +- .../window/window_boundaries_state.cpp | 146 ++++++++++++++++-- .../function/window/window_segment_tree.cpp | 72 ++++++--- .../common/arrow/arrow_type_extension.hpp | 2 + .../csv_scanner/sniffer/csv_sniffer.hpp | 2 + .../operator/persistent/physical_insert.hpp | 11 +- .../table/arrow/arrow_duck_schema.hpp | 1 + .../function/table/system_functions.hpp | 4 + .../window/window_boundaries_state.hpp | 4 +- src/duckdb/src/include/duckdb/main/config.hpp | 2 + .../include/duckdb/main/extension_entries.hpp | 1 + .../src/include/duckdb/main/secret/secret.hpp | 2 + .../duckdb/main/secret/secret_manager.hpp | 3 + .../src/include/duckdb/main/settings.hpp | 10 ++ .../parser/expression/window_expression.hpp | 45 ++++-- .../parser/query_node/set_operation_node.hpp | 10 +- src/duckdb/src/main/config.cpp | 1 + src/duckdb/src/main/secret/secret_manager.cpp | 11 ++ .../src/main/settings/custom_settings.cpp | 44 ++++++ src/duckdb/src/optimizer/filter_pushdown.cpp | 39 ++++- .../parser/query_node/set_operation_node.cpp | 49 ++++++ .../expression/transform_function.cpp | 34 ++-- .../expression_binder/index_binder.cpp | 1 + .../serialization/serialize_query_node.cpp | 12 +- .../storage/table/row_group_collection.cpp | 95 ++++++++---- ..._core_functions_aggregate_distributive.cpp | 20 +-- ...sion_core_functions_aggregate_holistic.cpp | 6 +- ...ension_core_functions_aggregate_nested.cpp | 4 +- ...on_core_functions_aggregate_regression.cpp | 12 +- ..._extension_core_functions_scalar_array.cpp | 4 +- ...b_extension_core_functions_scalar_date.cpp | 18 +-- ...b_extension_core_functions_scalar_list.cpp | 18 +-- ...ub_extension_core_functions_scalar_map.cpp | 10 +- ...extension_core_functions_scalar_string.cpp | 44 +++--- ..._extension_core_functions_scalar_union.cpp | 4 +- src/duckdb/ub_src_function_table_system.cpp | 2 + 50 files changed, 815 insertions(+), 210 deletions(-) create mode 100644 src/duckdb/src/function/table/system/duckdb_secret_types.cpp diff --git a/src/duckdb/src/common/arrow/arrow_type_extension.cpp b/src/duckdb/src/common/arrow/arrow_type_extension.cpp index 8a9779b08..de2e06970 100644 --- a/src/duckdb/src/common/arrow/arrow_type_extension.cpp +++ b/src/duckdb/src/common/arrow/arrow_type_extension.cpp @@ -14,6 +14,11 @@ ArrowTypeExtension::ArrowTypeExtension(string extension_name, string arrow_forma : extension_metadata(std::move(extension_name), {}, {}, std::move(arrow_format)), type_extension(std::move(type)) { } +ArrowTypeExtension::ArrowTypeExtension(ArrowExtensionMetadata &extension_metadata, unique_ptr type) + : extension_metadata(extension_metadata) { + type_extension = make_shared_ptr(type->GetDuckType()); +} + ArrowExtensionMetadata::ArrowExtensionMetadata(string extension_name, string vendor_name, string type_name, string arrow_format) : extension_name(std::move(extension_name)), vendor_name(std::move(vendor_name)), type_name(std::move(type_name)), @@ -197,10 +202,12 @@ ArrowTypeExtension GetArrowExtensionInternal( unordered_map &type_extensions, ArrowExtensionMetadata info) { if (type_extensions.find(info) == type_extensions.end()) { + auto og_info = info; info.SetArrowFormat(""); if (type_extensions.find(info) == type_extensions.end()) { - throw NotImplementedException("Arrow Extension with configuration:\n%s not yet registered", - info.ToString()); + auto format = og_info.GetArrowFormat(); + auto type = ArrowType::GetTypeFromFormat(format); + return ArrowTypeExtension(og_info, std::move(type)); } } return type_extensions[info]; diff --git a/src/duckdb/src/common/arrow/schema_metadata.cpp b/src/duckdb/src/common/arrow/schema_metadata.cpp index 4e259743f..f78f2ebfb 100644 --- a/src/duckdb/src/common/arrow/schema_metadata.cpp +++ b/src/duckdb/src/common/arrow/schema_metadata.cpp @@ -66,7 +66,7 @@ ArrowSchemaMetadata ArrowSchemaMetadata::NonCanonicalType(const string &type_nam bool ArrowSchemaMetadata::HasExtension() const { auto arrow_extension = GetOption(ArrowSchemaMetadata::ARROW_EXTENSION_NAME); - return !arrow_extension.empty() && !StringUtil::StartsWith(arrow_extension, "ogc"); + return !arrow_extension.empty(); } ArrowExtensionMetadata ArrowSchemaMetadata::GetExtensionInfo(string format) { diff --git a/src/duckdb/src/common/enum_util.cpp b/src/duckdb/src/common/enum_util.cpp index 56f61fc12..0ac5bb0c4 100644 --- a/src/duckdb/src/common/enum_util.cpp +++ b/src/duckdb/src/common/enum_util.cpp @@ -4283,19 +4283,22 @@ const StringUtil::EnumStringLiteral *GetWindowBoundaryValues() { { static_cast(WindowBoundary::EXPR_PRECEDING_ROWS), "EXPR_PRECEDING_ROWS" }, { static_cast(WindowBoundary::EXPR_FOLLOWING_ROWS), "EXPR_FOLLOWING_ROWS" }, { static_cast(WindowBoundary::EXPR_PRECEDING_RANGE), "EXPR_PRECEDING_RANGE" }, - { static_cast(WindowBoundary::EXPR_FOLLOWING_RANGE), "EXPR_FOLLOWING_RANGE" } + { static_cast(WindowBoundary::EXPR_FOLLOWING_RANGE), "EXPR_FOLLOWING_RANGE" }, + { static_cast(WindowBoundary::CURRENT_ROW_GROUPS), "CURRENT_ROW_GROUPS" }, + { static_cast(WindowBoundary::EXPR_PRECEDING_GROUPS), "EXPR_PRECEDING_GROUPS" }, + { static_cast(WindowBoundary::EXPR_FOLLOWING_GROUPS), "EXPR_FOLLOWING_GROUPS" } }; return values; } template<> const char* EnumUtil::ToChars(WindowBoundary value) { - return StringUtil::EnumToString(GetWindowBoundaryValues(), 9, "WindowBoundary", static_cast(value)); + return StringUtil::EnumToString(GetWindowBoundaryValues(), 12, "WindowBoundary", static_cast(value)); } template<> WindowBoundary EnumUtil::FromString(const char *value) { - return static_cast(StringUtil::StringToEnum(GetWindowBoundaryValues(), 9, "WindowBoundary", value)); + return static_cast(StringUtil::StringToEnum(GetWindowBoundaryValues(), 12, "WindowBoundary", value)); } const StringUtil::EnumStringLiteral *GetWindowExcludeModeValues() { diff --git a/src/duckdb/src/execution/operator/csv_scanner/sniffer/header_detection.cpp b/src/duckdb/src/execution/operator/csv_scanner/sniffer/header_detection.cpp index 6581018c7..f973e8784 100644 --- a/src/duckdb/src/execution/operator/csv_scanner/sniffer/header_detection.cpp +++ b/src/duckdb/src/execution/operator/csv_scanner/sniffer/header_detection.cpp @@ -335,7 +335,7 @@ void CSVSniffer::DetectHeader() { auto &sniffer_state_machine = best_candidate->GetStateMachine(); names = DetectHeaderInternal(buffer_manager->context, best_header_row, sniffer_state_machine, set_columns, best_sql_types_candidates_per_column_idx, options, *error_handler); - if (single_row_file && sniffer_state_machine.dialect_options.header.GetValue()) { + if (EmptyOrOnlyHeader()) { // This file only contains a header, lets default to the lowest type of all. detected_types.clear(); for (idx_t i = 0; i < names.size(); i++) { diff --git a/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_detection.cpp b/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_detection.cpp index e58b66433..f362c8952 100644 --- a/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_detection.cpp +++ b/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_detection.cpp @@ -99,6 +99,10 @@ idx_t CSVSniffer::LinesSniffed() const { return lines_sniffed; } +bool CSVSniffer::EmptyOrOnlyHeader() const { + return (single_row_file && best_candidate->state_machine->dialect_options.header.GetValue()) || lines_sniffed == 0; +} + bool CSVSniffer::CanYouCastIt(ClientContext &context, const string_t value, const LogicalType &type, const DialectOptions &dialect_options, const bool is_null, const char decimal_separator) { if (is_null) { diff --git a/src/duckdb/src/execution/operator/persistent/physical_delete.cpp b/src/duckdb/src/execution/operator/persistent/physical_delete.cpp index e92e2ec66..7d494ac0c 100644 --- a/src/duckdb/src/execution/operator/persistent/physical_delete.cpp +++ b/src/duckdb/src/execution/operator/persistent/physical_delete.cpp @@ -47,7 +47,10 @@ class DeleteLocalState : public LocalSinkState { public: DeleteLocalState(ClientContext &context, TableCatalogEntry &table, const vector> &bound_constraints) { - delete_chunk.Initialize(Allocator::Get(context), table.GetTypes()); + const auto &types = table.GetTypes(); + auto initialize = vector(types.size(), false); + delete_chunk.Initialize(Allocator::Get(context), types, initialize); + auto &storage = table.GetStorage(); delete_state = storage.InitializeDelete(table, context, bound_constraints); } @@ -64,22 +67,66 @@ SinkResultType PhysicalDelete::Sink(ExecutionContext &context, DataChunk &chunk, auto &transaction = DuckTransaction::Get(context.client, table.db); auto &row_ids = chunk.data[row_id_index]; - vector column_ids; - for (idx_t i = 0; i < table.ColumnCount(); i++) { - column_ids.emplace_back(i); - }; - auto fetch_state = ColumnFetchState(); - lock_guard delete_guard(g_state.delete_lock); if (!return_chunk && !g_state.has_unique_indexes) { g_state.deleted_count += table.Delete(*l_state.delete_state, context.client, row_ids, chunk.size()); return SinkResultType::NEED_MORE_INPUT; } - // Fetch the to-be-deleted chunk. + auto types = table.GetTypes(); + auto to_be_fetched = vector(types.size(), return_chunk); + vector column_ids; + vector column_types; + if (return_chunk) { + // Fetch all columns. + column_types = types; + for (idx_t i = 0; i < table.ColumnCount(); i++) { + column_ids.emplace_back(i); + } + + } else { + // Fetch only the required columns for updating the delete indexes. + auto &local_storage = LocalStorage::Get(context.client, table.db); + auto storage = local_storage.GetStorage(table); + unordered_set indexed_column_id_set; + storage->delete_indexes.Scan([&](Index &index) { + if (!index.IsBound() || !index.IsUnique()) { + return false; + } + auto &set = index.GetColumnIdSet(); + indexed_column_id_set.insert(set.begin(), set.end()); + return false; + }); + for (auto &col : indexed_column_id_set) { + column_ids.emplace_back(col); + } + sort(column_ids.begin(), column_ids.end()); + for (auto &col : column_ids) { + auto i = col.GetPrimaryIndex(); + to_be_fetched[i] = true; + column_types.push_back(types[i]); + } + } + l_state.delete_chunk.Reset(); row_ids.Flatten(chunk.size()); - table.Fetch(transaction, l_state.delete_chunk, column_ids, row_ids, chunk.size(), fetch_state); + + // Fetch the to-be-deleted chunk. + DataChunk fetch_chunk; + fetch_chunk.Initialize(Allocator::Get(context.client), column_types, chunk.size()); + auto fetch_state = ColumnFetchState(); + table.Fetch(transaction, fetch_chunk, column_ids, row_ids, chunk.size(), fetch_state); + + // Reference the necessary columns of the fetch_chunk. + idx_t fetch_idx = 0; + for (idx_t i = 0; i < table.ColumnCount(); i++) { + if (to_be_fetched[i]) { + l_state.delete_chunk.data[i].Reference(fetch_chunk.data[fetch_idx++]); + continue; + } + l_state.delete_chunk.data[i].Reference(Value(types[i])); + } + l_state.delete_chunk.SetCardinality(fetch_chunk); // Append the deleted row IDs to the delete indexes. // If we only delete local row IDs, then the delete_chunk is empty. diff --git a/src/duckdb/src/execution/operator/persistent/physical_insert.cpp b/src/duckdb/src/execution/operator/persistent/physical_insert.cpp index dac3491fe..cb21cc26b 100644 --- a/src/duckdb/src/execution/operator/persistent/physical_insert.cpp +++ b/src/duckdb/src/execution/operator/persistent/physical_insert.cpp @@ -80,15 +80,17 @@ InsertGlobalState::InsertGlobalState(ClientContext &context, const vector &types, +InsertLocalState::InsertLocalState(ClientContext &context, const vector &types_p, const vector> &bound_defaults, const vector> &bound_constraints) : default_executor(context, bound_defaults), bound_constraints(bound_constraints) { auto &allocator = Allocator::Get(context); - insert_chunk.Initialize(allocator, types); - update_chunk.Initialize(allocator, types); - append_chunk.Initialize(allocator, types); + + types = types_p; + auto initialize = vector(types.size(), false); + update_chunk.Initialize(allocator, types, initialize); + append_chunk.Initialize(allocator, types, initialize); } ConstraintState &InsertLocalState::GetConstraintState(DataTable &table, TableCatalogEntry &table_ref) { @@ -185,8 +187,10 @@ static void CombineExistingAndInsertTuples(DataChunk &result, DataChunk &scan_ch auto &insert_types = op.insert_types; if (types_to_fetch.empty()) { - // We have not scanned the initial table, so we can just duplicate the initial chunk - result.Initialize(client, input_chunk.GetTypes()); + // We have not scanned the initial table, so we duplicate the initial chunk. + const auto &types = input_chunk.GetTypes(); + auto initialize = vector(types.size(), false); + result.Initialize(client, types, initialize, input_chunk.size()); result.Reference(input_chunk); result.SetCardinality(input_chunk); return; @@ -196,7 +200,7 @@ static void CombineExistingAndInsertTuples(DataChunk &result, DataChunk &scan_ch combined_types.insert(combined_types.end(), insert_types.begin(), insert_types.end()); combined_types.insert(combined_types.end(), types_to_fetch.begin(), types_to_fetch.end()); - result.Initialize(client, combined_types); + result.Initialize(client, combined_types, input_chunk.size()); result.Reset(); // Add the VALUES list for (idx_t i = 0; i < insert_types.size(); i++) { @@ -223,12 +227,13 @@ static void CombineExistingAndInsertTuples(DataChunk &result, DataChunk &scan_ch result.SetCardinality(input_chunk.size()); } -static void CreateUpdateChunk(ExecutionContext &context, DataChunk &chunk, TableCatalogEntry &table, Vector &row_ids, - DataChunk &update_chunk, const PhysicalInsert &op) { +static void CreateUpdateChunk(ExecutionContext &context, DataChunk &chunk, Vector &row_ids, DataChunk &update_chunk, + const PhysicalInsert &op) { auto &do_update_condition = op.do_update_condition; auto &set_types = op.set_types; auto &set_expressions = op.set_expressions; + // Check the optional condition for the DO UPDATE clause, to filter which rows will be updated if (do_update_condition) { DataChunk do_update_filter_result; @@ -255,8 +260,15 @@ static void CreateUpdateChunk(ExecutionContext &context, DataChunk &chunk, Table } } - // Execute the SET expressions - update_chunk.Initialize(context.client, set_types); + if (chunk.size() == 0) { + auto initialize = vector(set_types.size(), false); + update_chunk.Initialize(context.client, set_types, initialize, chunk.size()); + update_chunk.SetCardinality(chunk); + return; + } + + // Execute the SET expressions. + update_chunk.Initialize(context.client, set_types, chunk.size()); ExpressionExecutor executor(context.client, set_expressions); executor.Execute(chunk, update_chunk); update_chunk.SetCardinality(chunk); @@ -272,7 +284,7 @@ static idx_t PerformOnConflictAction(InsertLocalState &lstate, ExecutionContext auto &set_columns = op.set_columns; DataChunk update_chunk; - CreateUpdateChunk(context, chunk, table, row_ids, update_chunk, op); + CreateUpdateChunk(context, chunk, row_ids, update_chunk, op); auto &data_table = table.GetStorage(); // Perform the UPDATE on the (global) storage. @@ -476,7 +488,9 @@ static idx_t HandleInsertConflicts(TableCatalogEntry &table, ExecutionContext &c DataChunk combined_chunk; // contains conflict_chunk + scan_chunk (wide) // Filter out everything but the conflicting rows - conflict_chunk.Initialize(context.client, tuples.GetTypes()); + const auto &types = tuples.GetTypes(); + auto initialize = vector(types.size(), false); + conflict_chunk.Initialize(context.client, types, initialize, tuples.size()); conflict_chunk.Reference(tuples); conflict_chunk.Slice(conflicts.Selection(), conflicts.Count()); conflict_chunk.SetCardinality(conflicts.Count()); @@ -487,7 +501,7 @@ static idx_t HandleInsertConflicts(TableCatalogEntry &table, ExecutionContext &c D_ASSERT(scan_chunk.size() == 0); // When these values are required for the conditions or the SET expressions, // then we scan the existing table for the conflicting tuples, using the rowids - scan_chunk.Initialize(context.client, types_to_fetch); + scan_chunk.Initialize(context.client, types_to_fetch, conflicts.Count()); fetch_state = make_uniq(); if (GLOBAL) { auto &transaction = DuckTransaction::Get(context.client, table.catalog); @@ -520,7 +534,7 @@ static idx_t HandleInsertConflicts(TableCatalogEntry &table, ExecutionContext &c return affected_tuples; } -idx_t PhysicalInsert::OnConflictHandling(TableCatalogEntry &table, ExecutionContext &context, InsertGlobalState &gstate, +idx_t PhysicalInsert::OnConflictHandling(TableCatalogEntry &table, ExecutionContext &context, InsertLocalState &lstate) const { auto &data_table = table.GetStorage(); auto &local_storage = LocalStorage::Get(context.client, data_table.db); @@ -620,6 +634,21 @@ SinkResultType PhysicalInsert::Sink(ExecutionContext &context, DataChunk &chunk, auto &table = gstate.table; auto &storage = table.GetStorage(); + if (lstate.init_insert_chunk) { + auto initialize = vector(lstate.types.size(), false); + if (!column_index_map.empty()) { + for (auto &col : table.GetColumns().Physical()) { + auto storage_idx = col.StorageOid(); + auto mapped_index = column_index_map[col.Physical()]; + if (mapped_index == DConstants::INVALID_INDEX) { + initialize[storage_idx] = true; + } + } + } + auto &allocator = Allocator::Get(context.client); + lstate.insert_chunk.Initialize(allocator, lstate.types, initialize, chunk.size()); + lstate.init_insert_chunk = false; + } PhysicalInsert::ResolveDefaults(table, chunk, column_index_map, lstate.default_executor, lstate.insert_chunk); if (!parallel) { @@ -634,7 +663,7 @@ SinkResultType PhysicalInsert::Sink(ExecutionContext &context, DataChunk &chunk, // so it should not be added to the RETURNING chunk gstate.return_collection.Append(lstate.insert_chunk); } - idx_t updated_tuples = OnConflictHandling(table, context, gstate, lstate); + idx_t updated_tuples = OnConflictHandling(table, context, lstate); if (action_type == OnConflictAction::NOTHING && return_chunk) { // Because we didn't add to the RETURNING chunk yet // we add the tuples that did not get filtered out now @@ -665,7 +694,7 @@ SinkResultType PhysicalInsert::Sink(ExecutionContext &context, DataChunk &chunk, lstate.local_collection->InitializeAppend(lstate.local_append_state); lstate.writer = &gstate.table.GetStorage().CreateOptimisticWriter(context.client); } - OnConflictHandling(table, context, gstate, lstate); + OnConflictHandling(table, context, lstate); D_ASSERT(action_type != OnConflictAction::UPDATE); auto new_row_group = lstate.local_collection->Append(lstate.insert_chunk, lstate.local_append_state); diff --git a/src/duckdb/src/function/compression_config.cpp b/src/duckdb/src/function/compression_config.cpp index deece1a85..8700371fc 100644 --- a/src/duckdb/src/function/compression_config.cpp +++ b/src/duckdb/src/function/compression_config.cpp @@ -65,6 +65,10 @@ static optional_ptr LoadCompressionFunction(CompressionFunc static void TryLoadCompression(DBConfig &config, vector> &result, CompressionType type, const PhysicalType physical_type) { + if (config.options.disabled_compression_methods.find(type) != config.options.disabled_compression_methods.end()) { + // explicitly disabled + return; + } auto function = config.GetCompressionFunction(type, physical_type); if (!function) { return; diff --git a/src/duckdb/src/function/table/arrow/arrow_duck_schema.cpp b/src/duckdb/src/function/table/arrow/arrow_duck_schema.cpp index a3245efff..2220c3636 100644 --- a/src/duckdb/src/function/table/arrow/arrow_duck_schema.cpp +++ b/src/duckdb/src/function/table/arrow/arrow_duck_schema.cpp @@ -56,7 +56,7 @@ void ArrowType::ThrowIfInvalid() const { } } -unique_ptr ArrowType::GetTypeFromFormat(DBConfig &config, ArrowSchema &schema, string &format) { +unique_ptr ArrowType::GetTypeFromFormat(string &format) { if (format == "n") { return make_uniq(LogicalType::SQLNULL); } else if (format == "b") { @@ -179,6 +179,14 @@ unique_ptr ArrowType::GetTypeFromFormat(DBConfig &config, ArrowSchema } return make_uniq(LogicalType::TIMESTAMP_TZ, std::move(type_info)); } + return nullptr; +} + +unique_ptr ArrowType::GetTypeFromFormat(DBConfig &config, ArrowSchema &schema, string &format) { + auto type = GetTypeFromFormat(format); + if (type) { + return type; + } if (format == "+l") { return CreateListType(config, *schema.children[0], ArrowVariableSizeType::NORMAL, false); } else if (format == "+L") { diff --git a/src/duckdb/src/function/table/read_csv.cpp b/src/duckdb/src/function/table/read_csv.cpp index f01934e7b..706712f81 100644 --- a/src/duckdb/src/function/table/read_csv.cpp +++ b/src/duckdb/src/function/table/read_csv.cpp @@ -62,6 +62,8 @@ void SchemaDiscovery(ClientContext &context, ReadCSVData &result, CSVReaderOptio options.file_path = file_paths[current_file]; result.buffer_manager = make_shared_ptr(context, options, options.file_path, 0, false); + idx_t only_header_or_empty_files = 0; + { CSVSniffer sniffer(options, result.buffer_manager, CSVStateMachineCache::Get(context)); auto sniffer_result = sniffer.SniffCSV(); @@ -71,14 +73,17 @@ void SchemaDiscovery(ClientContext &context, ReadCSVData &result, CSVReaderOptio schemas.emplace_back(sniffer_result.names, sniffer_result.return_types, file_paths[0], rows_read, result.buffer_manager->GetBuffer(0)->actual_size == 0); total_number_of_rows += sniffer.LinesSniffed(); + current_file++; + if (sniffer.EmptyOrOnlyHeader()) { + only_header_or_empty_files++; + } } // We do a copy of the options to not pollute the options of the first file. constexpr idx_t max_files_to_sniff = 10; idx_t files_to_sniff = file_paths.size() > max_files_to_sniff ? max_files_to_sniff : file_paths.size(); - while (total_number_of_rows < required_number_of_lines && current_file + 1 < files_to_sniff) { + while (total_number_of_rows < required_number_of_lines && current_file < files_to_sniff) { auto option_copy = option_og; - current_file++; option_copy.file_path = file_paths[current_file]; auto buffer_manager = make_shared_ptr(context, option_copy, option_copy.file_path, current_file, false); @@ -94,6 +99,10 @@ void SchemaDiscovery(ClientContext &context, ReadCSVData &result, CSVReaderOptio schemas.emplace_back(sniffer_result.names, sniffer_result.return_types, option_copy.file_path, rows_read); } total_number_of_rows += sniffer.LinesSniffed(); + if (sniffer.EmptyOrOnlyHeader()) { + only_header_or_empty_files++; + } + current_file++; } // We might now have multiple schemas, we need to go through them to define the one true schema @@ -115,6 +124,13 @@ void SchemaDiscovery(ClientContext &context, ReadCSVData &result, CSVReaderOptio names = best_schema.GetNames(); return_types = best_schema.GetTypes(); } + if (only_header_or_empty_files == current_file) { + for (auto &type : return_types) { + D_ASSERT(type.id() == LogicalTypeId::BOOLEAN); + // we default to varchar if all files are empty or only have a header after all the sniffing + type = LogicalType::VARCHAR; + } + } result.csv_types = return_types; result.csv_names = names; } diff --git a/src/duckdb/src/function/table/sniff_csv.cpp b/src/duckdb/src/function/table/sniff_csv.cpp index 5c72aabb9..1e236a5c7 100644 --- a/src/duckdb/src/function/table/sniff_csv.cpp +++ b/src/duckdb/src/function/table/sniff_csv.cpp @@ -152,6 +152,13 @@ static void CSVSniffFunction(ClientContext &context, TableFunctionInput &data_p, } CSVSniffer sniffer(sniffer_options, buffer_manager, CSVStateMachineCache::Get(context)); auto sniffer_result = sniffer.SniffCSV(data.force_match); + if (sniffer.EmptyOrOnlyHeader()) { + for (auto &type : sniffer_result.return_types) { + D_ASSERT(type.id() == LogicalTypeId::BOOLEAN); + // we default to varchar if all files are empty or only have a header after all the sniffing + type = LogicalType::VARCHAR; + } + } string str_opt; string separator = ", "; // Set output diff --git a/src/duckdb/src/function/table/system/duckdb_secret_types.cpp b/src/duckdb/src/function/table/system/duckdb_secret_types.cpp new file mode 100644 index 000000000..a0c634c28 --- /dev/null +++ b/src/duckdb/src/function/table/system/duckdb_secret_types.cpp @@ -0,0 +1,71 @@ +#include "duckdb/function/table/system_functions.hpp" +#include "duckdb/main/config.hpp" +#include "duckdb/main/client_context.hpp" +#include "duckdb/common/enum_util.hpp" +#include "duckdb/main/secret/secret_manager.hpp" +#include "duckdb/main/secret/secret.hpp" + +namespace duckdb { + +struct DuckDBSecretTypesData : public GlobalTableFunctionState { + DuckDBSecretTypesData() : offset(0) { + } + + vector types; + idx_t offset; +}; + +static unique_ptr DuckDBSecretTypesBind(ClientContext &context, TableFunctionBindInput &input, + vector &return_types, vector &names) { + names.emplace_back("type"); + return_types.emplace_back(LogicalType::VARCHAR); + + names.emplace_back("default_provider"); + return_types.emplace_back(LogicalType::VARCHAR); + + names.emplace_back("extension"); + return_types.emplace_back(LogicalType::VARCHAR); + + return nullptr; +} + +unique_ptr DuckDBSecretTypesInit(ClientContext &context, TableFunctionInitInput &input) { + auto result = make_uniq(); + + auto &secret_manager = SecretManager::Get(context); + result->types = secret_manager.AllSecretTypes(); + + return std::move(result); +} + +void DuckDBSecretTypesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) { + auto &data = data_p.global_state->Cast(); + if (data.offset >= data.types.size()) { + // finished returning values + return; + } + // start returning values + // either fill up the chunk or return all the remaining columns + idx_t count = 0; + while (data.offset < data.types.size() && count < STANDARD_VECTOR_SIZE) { + auto &entry = data.types[data.offset++]; + + // return values: + // type, LogicalType::VARCHAR + output.SetValue(0, count, Value(entry.name)); + // default_provider, LogicalType::VARCHAR + output.SetValue(1, count, Value(entry.default_provider)); + // extension, LogicalType::VARCHAR + output.SetValue(2, count, Value(entry.extension)); + + count++; + } + output.SetCardinality(count); +} + +void DuckDBSecretTypesFun::RegisterFunction(BuiltinFunctions &set) { + set.AddFunction(TableFunction("duckdb_secret_types", {}, DuckDBSecretTypesFunction, DuckDBSecretTypesBind, + DuckDBSecretTypesInit)); +} + +} // namespace duckdb diff --git a/src/duckdb/src/function/table/system_functions.cpp b/src/duckdb/src/function/table/system_functions.cpp index 71eb52e00..972eb7e54 100644 --- a/src/duckdb/src/function/table/system_functions.cpp +++ b/src/duckdb/src/function/table/system_functions.cpp @@ -33,6 +33,7 @@ void BuiltinFunctions::RegisterSQLiteFunctions() { DuckDBOptimizersFun::RegisterFunction(*this); DuckDBSecretsFun::RegisterFunction(*this); DuckDBWhichSecretFun::RegisterFunction(*this); + DuckDBSecretTypesFun::RegisterFunction(*this); DuckDBSequencesFun::RegisterFunction(*this); DuckDBSettingsFun::RegisterFunction(*this); DuckDBTablesFun::RegisterFunction(*this); diff --git a/src/duckdb/src/function/table/version/pragma_version.cpp b/src/duckdb/src/function/table/version/pragma_version.cpp index 2ba223d9f..0197afdba 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 "4-dev4679" +#define DUCKDB_PATCH_VERSION "4-dev4760" #endif #ifndef DUCKDB_MINOR_VERSION #define DUCKDB_MINOR_VERSION 1 @@ -8,10 +8,10 @@ #define DUCKDB_MAJOR_VERSION 1 #endif #ifndef DUCKDB_VERSION -#define DUCKDB_VERSION "v1.1.4-dev4679" +#define DUCKDB_VERSION "v1.1.4-dev4760" #endif #ifndef DUCKDB_SOURCE_ID -#define DUCKDB_SOURCE_ID "0024e5d4be" +#define DUCKDB_SOURCE_ID "9c133491ad" #endif #include "duckdb/function/table/system_functions.hpp" #include "duckdb/main/database.hpp" diff --git a/src/duckdb/src/function/window/window_aggregate_function.cpp b/src/duckdb/src/function/window/window_aggregate_function.cpp index f08fc5dbc..07fa8f3ec 100644 --- a/src/duckdb/src/function/window/window_aggregate_function.cpp +++ b/src/duckdb/src/function/window/window_aggregate_function.cpp @@ -194,7 +194,12 @@ static void ApplyWindowStats(const WindowBoundary &boundary, FrameDelta &delta, case WindowBoundary::EXPR_PRECEDING_RANGE: case WindowBoundary::EXPR_FOLLOWING_RANGE: return; - default: + case WindowBoundary::CURRENT_ROW_GROUPS: + case WindowBoundary::EXPR_PRECEDING_GROUPS: + case WindowBoundary::EXPR_FOLLOWING_GROUPS: + return; + case WindowBoundary::INVALID: + throw InternalException(is_start ? "Unknown window start boundary" : "Unknown window end boundary"); break; } diff --git a/src/duckdb/src/function/window/window_boundaries_state.cpp b/src/duckdb/src/function/window/window_boundaries_state.cpp index 7727e2a63..60b59cace 100644 --- a/src/duckdb/src/function/window/window_boundaries_state.cpp +++ b/src/duckdb/src/function/window/window_boundaries_state.cpp @@ -374,7 +374,7 @@ WindowBoundsSet WindowBoundariesState::GetWindowBounds(const BoundWindowExpressi result.insert(FRAME_END); break; default: - throw InternalException("Window aggregate type %s", ExpressionTypeToString(wexpr.GetExpressionType())); + throw InternalException("Window expression type %s", ExpressionTypeToString(wexpr.GetExpressionType())); } // Internal dependencies @@ -388,11 +388,12 @@ WindowBoundsSet WindowBoundariesState::GetWindowBounds(const BoundWindowExpressi result.insert(PEER_END); } - // If the frames are RANGE, then we need peer boundaries - // If they are preceding or following, we also need to know + // If the frames are RANGE or GROUPS, then we need peer boundaries + // If they are preceding or following, RANGE also needs to know // where the valid values begin or end. switch (wexpr.start) { case WindowBoundary::CURRENT_ROW_RANGE: + case WindowBoundary::CURRENT_ROW_GROUPS: result.insert(PEER_BEGIN); break; case WindowBoundary::EXPR_PRECEDING_RANGE: @@ -404,12 +405,24 @@ WindowBoundsSet WindowBoundariesState::GetWindowBounds(const BoundWindowExpressi result.insert(PEER_BEGIN); result.insert(VALID_END); break; - default: + case WindowBoundary::EXPR_PRECEDING_GROUPS: + result.insert(PEER_BEGIN); + break; + case WindowBoundary::EXPR_FOLLOWING_GROUPS: + result.insert(PEER_BEGIN); + break; + case WindowBoundary::UNBOUNDED_PRECEDING: + case WindowBoundary::UNBOUNDED_FOLLOWING: + case WindowBoundary::CURRENT_ROW_ROWS: + case WindowBoundary::EXPR_PRECEDING_ROWS: + case WindowBoundary::EXPR_FOLLOWING_ROWS: + case WindowBoundary::INVALID: break; } switch (wexpr.end) { case WindowBoundary::CURRENT_ROW_RANGE: + case WindowBoundary::CURRENT_ROW_GROUPS: result.insert(PEER_END); break; case WindowBoundary::EXPR_PRECEDING_RANGE: @@ -421,7 +434,18 @@ WindowBoundsSet WindowBoundariesState::GetWindowBounds(const BoundWindowExpressi result.insert(VALID_BEGIN); result.insert(VALID_END); break; - default: + case WindowBoundary::EXPR_PRECEDING_GROUPS: + result.insert(PEER_END); + break; + case WindowBoundary::EXPR_FOLLOWING_GROUPS: + result.insert(PEER_END); + break; + case WindowBoundary::UNBOUNDED_PRECEDING: + case WindowBoundary::UNBOUNDED_FOLLOWING: + case WindowBoundary::CURRENT_ROW_ROWS: + case WindowBoundary::EXPR_PRECEDING_ROWS: + case WindowBoundary::EXPR_FOLLOWING_ROWS: + case WindowBoundary::INVALID: break; } } @@ -483,10 +507,10 @@ void WindowBoundariesState::Bounds(DataChunk &bounds, idx_t row_idx, optional_pt ValidEnd(bounds, row_idx, count, is_jump, partition_mask, order_mask, range); } if (required.count(FRAME_BEGIN)) { - FrameBegin(bounds, row_idx, count, boundary_start, range); + FrameBegin(bounds, row_idx, count, boundary_start, order_mask, range); } if (required.count(FRAME_END)) { - FrameEnd(bounds, row_idx, count, boundary_end, range); + FrameEnd(bounds, row_idx, count, boundary_end, order_mask, range); } next_pos += count; @@ -683,7 +707,8 @@ void WindowBoundariesState::ValidEnd(DataChunk &bounds, idx_t row_idx, const idx } void WindowBoundariesState::FrameBegin(DataChunk &bounds, idx_t row_idx, const idx_t count, - WindowInputExpression &boundary_begin, optional_ptr range) { + WindowInputExpression &boundary_begin, const ValidityMask &order_mask, + optional_ptr range) { auto partition_begin_data = FlatVector::GetData(bounds.data[PARTITION_BEGIN]); auto partition_end_data = FlatVector::GetData(bounds.data[PARTITION_END]); auto peer_begin_data = FlatVector::GetData(bounds.data[PEER_BEGIN]); @@ -704,6 +729,9 @@ void WindowBoundariesState::FrameBegin(DataChunk &bounds, idx_t row_idx, const i } break; case WindowBoundary::CURRENT_ROW_RANGE: + case WindowBoundary::CURRENT_ROW_GROUPS: + // in RANGE or GROUPS mode it means that the frame starts or ends with the current row's + // first or last peer in the ORDER BY ordering bounds.data[FRAME_BEGIN].Reference(bounds.data[PEER_BEGIN]); frame_begin_data = peer_begin_data; break; @@ -759,7 +787,53 @@ void WindowBoundariesState::FrameBegin(DataChunk &bounds, idx_t row_idx, const i frame_begin_data[chunk_idx] = window_start; } break; - default: + case WindowBoundary::EXPR_PRECEDING_GROUPS: + // In GROUPS mode, the offset is an integer indicating that the frame starts or ends that many peer groups + // before or after the current row's peer group, where a peer group is a group of rows that are equivalent + // according to the window's ORDER BY clause. + for (idx_t chunk_idx = 0; chunk_idx < count; ++chunk_idx, ++row_idx) { + if (boundary_begin.CellIsNull(chunk_idx)) { + window_start = peer_begin_data[chunk_idx]; + } else { + // Count peer groups backwards. + const auto peer_begin = peer_begin_data[chunk_idx]; + const auto partition_begin = partition_begin_data[chunk_idx]; + const auto boundary = boundary_begin.GetCell(chunk_idx); + if (boundary < 0) { + throw OutOfRangeException("Invalid GROUPS PRECEDING value"); + } else if (!boundary) { + window_start = peer_begin; + } else { + auto n = UnsafeNumericCast(boundary); + window_start = FindPrevStart(order_mask, partition_begin, peer_begin, n); + } + } + frame_begin_data[chunk_idx] = window_start; + } + break; + case WindowBoundary::EXPR_FOLLOWING_GROUPS: + for (idx_t chunk_idx = 0; chunk_idx < count; ++chunk_idx, ++row_idx) { + if (boundary_begin.CellIsNull(chunk_idx)) { + window_start = peer_begin_data[chunk_idx]; + } else { + // Count peer groups forward. + const auto peer_begin = peer_begin_data[chunk_idx]; + const auto partition_end = partition_end_data[chunk_idx]; + const auto boundary = boundary_begin.GetCell(chunk_idx); + if (boundary < 0) { + throw OutOfRangeException("Invalid GROUPS FOLLOWING value"); + } else if (!boundary) { + window_start = peer_begin; + } else { + auto n = UnsafeNumericCast(boundary); + window_start = FindNextStart(order_mask, peer_begin + 1, partition_end, n); + } + } + frame_begin_data[chunk_idx] = window_start; + } + break; + case WindowBoundary::UNBOUNDED_FOLLOWING: + case WindowBoundary::INVALID: throw InternalException("Unsupported window start boundary"); } @@ -767,7 +841,8 @@ void WindowBoundariesState::FrameBegin(DataChunk &bounds, idx_t row_idx, const i } void WindowBoundariesState::FrameEnd(DataChunk &bounds, idx_t row_idx, const idx_t count, - WindowInputExpression &boundary_end, optional_ptr range) { + WindowInputExpression &boundary_end, const ValidityMask &order_mask, + optional_ptr range) { auto partition_begin_data = FlatVector::GetData(bounds.data[PARTITION_BEGIN]); auto partition_end_data = FlatVector::GetData(bounds.data[PARTITION_END]); auto peer_end_data = FlatVector::GetData(bounds.data[PEER_END]); @@ -784,6 +859,9 @@ void WindowBoundariesState::FrameEnd(DataChunk &bounds, idx_t row_idx, const idx } break; case WindowBoundary::CURRENT_ROW_RANGE: + case WindowBoundary::CURRENT_ROW_GROUPS: + // in RANGE or GROUPS mode it means that the frame starts or ends with the current row's + // first or last peer in the ORDER BY ordering bounds.data[FRAME_END].Reference(bounds.data[PEER_END]); frame_end_data = peer_end_data; break; @@ -844,7 +922,53 @@ void WindowBoundariesState::FrameEnd(DataChunk &bounds, idx_t row_idx, const idx frame_end_data[chunk_idx] = window_end; } break; - default: + case WindowBoundary::EXPR_PRECEDING_GROUPS: + // In GROUPS mode, the offset is an integer indicating that the frame starts or ends that many peer groups + // before or after the current row's peer group, where a peer group is a group of rows that are equivalent + // according to the window's ORDER BY clause. + for (idx_t chunk_idx = 0; chunk_idx < count; ++chunk_idx, ++row_idx) { + if (boundary_end.CellIsNull(chunk_idx)) { + window_end = peer_end_data[chunk_idx]; + } else { + // Count peer groups backwards. + const auto peer_end = peer_end_data[chunk_idx]; + const auto partition_begin = partition_begin_data[chunk_idx]; + const auto boundary = boundary_end.GetCell(chunk_idx); + if (boundary < 0) { + throw OutOfRangeException("Invalid GROUPS PRECEDING value"); + } else if (!boundary) { + window_end = peer_end; + } else { + auto n = UnsafeNumericCast(boundary); + window_end = FindPrevStart(order_mask, partition_begin, peer_end, n); + } + } + frame_end_data[chunk_idx] = window_end; + } + break; + case WindowBoundary::EXPR_FOLLOWING_GROUPS: + for (idx_t chunk_idx = 0; chunk_idx < count; ++chunk_idx, ++row_idx) { + if (boundary_end.CellIsNull(chunk_idx)) { + window_end = peer_end_data[chunk_idx]; + } else { + // Count peer groups forward. + const auto peer_end = peer_end_data[chunk_idx]; + const auto partition_end = partition_end_data[chunk_idx]; + const auto boundary = boundary_end.GetCell(chunk_idx); + if (boundary < 0) { + throw OutOfRangeException("Invalid GROUPS FOLLOWING value"); + } else if (!boundary) { + window_end = peer_end; + } else { + auto n = UnsafeNumericCast(boundary); + window_end = FindNextStart(order_mask, peer_end + 1, partition_end, n); + } + } + frame_end_data[chunk_idx] = window_end; + } + break; + case WindowBoundary::UNBOUNDED_PRECEDING: + case WindowBoundary::INVALID: throw InternalException("Unsupported window end boundary"); } diff --git a/src/duckdb/src/function/window/window_segment_tree.cpp b/src/duckdb/src/function/window/window_segment_tree.cpp index 6708ae90b..9168a4f22 100644 --- a/src/duckdb/src/function/window/window_segment_tree.cpp +++ b/src/duckdb/src/function/window/window_segment_tree.cpp @@ -79,17 +79,26 @@ class WindowSegmentTreePart { void Combine(WindowSegmentTreePart &other, idx_t count); - void Evaluate(const WindowSegmentTreeGlobalState &tree, const idx_t *begins, const idx_t *ends, Vector &result, - idx_t count, idx_t row_idx, FramePart frame_part); + void Evaluate(const WindowSegmentTreeGlobalState &tree, const idx_t *begins, const idx_t *ends, const idx_t *bounds, + Vector &result, idx_t count, idx_t row_idx, FramePart frame_part); protected: //! Initialises the accumulation state vector (statef) void Initialize(idx_t count); //! Accumulate upper tree levels void EvaluateUpperLevels(const WindowSegmentTreeGlobalState &tree, const idx_t *begins, const idx_t *ends, - idx_t count, idx_t row_idx, FramePart frame_part); - void EvaluateLeaves(const WindowSegmentTreeGlobalState &tree, const idx_t *begins, const idx_t *ends, idx_t count, - idx_t row_idx, FramePart frame_part, FramePart leaf_part); + const idx_t *bounds, idx_t count, idx_t row_idx, FramePart frame_part); + void EvaluateLeaves(const WindowSegmentTreeGlobalState &tree, const idx_t *begins, const idx_t *ends, + const idx_t *bounds, idx_t count, idx_t row_idx, FramePart frame_part, FramePart leaf_part); + + static inline const idx_t *FrameBegins(const idx_t *begins, const idx_t *ends, const idx_t *bounds, + FramePart frame_part) { + return frame_part == FramePart::RIGHT ? bounds : begins; + } + static inline const idx_t *FrameEnds(const idx_t *begins, const idx_t *ends, const idx_t *bounds, + FramePart frame_part) { + return frame_part == FramePart::LEFT ? bounds : ends; + } public: //! Allocator for aggregates @@ -400,8 +409,12 @@ void WindowSegmentTreeState::Evaluate(const WindowSegmentTreeGlobalState >stat } if (gtstate.aggregator.exclude_mode != WindowExcludeMode::NO_OTHER) { + // If we exclude the current row, then both left and right need to contain it. + const bool exclude_current = gtstate.aggregator.exclude_mode == WindowExcludeMode::CURRENT_ROW; + // 1. evaluate the tree left of the excluded part - part->Evaluate(gtstate, window_begin, peer_begin, result, count, row_idx, WindowSegmentTreePart::LEFT); + auto middle = exclude_current ? peer_end : peer_begin; + part->Evaluate(gtstate, window_begin, middle, window_end, result, count, row_idx, WindowSegmentTreePart::LEFT); // 2. set up a second state for the right of the excluded part if (!right_part) { @@ -409,32 +422,35 @@ void WindowSegmentTreeState::Evaluate(const WindowSegmentTreeGlobalState >stat } // 3. evaluate the tree right of the excluded part - right_part->Evaluate(gtstate, peer_end, window_end, result, count, row_idx, WindowSegmentTreePart::RIGHT); + middle = exclude_current ? peer_begin : peer_end; + right_part->Evaluate(gtstate, middle, window_end, window_begin, result, count, row_idx, + WindowSegmentTreePart::RIGHT); // 4. combine the buffer state into the Segment Tree State part->Combine(*right_part, count); } else { - part->Evaluate(gtstate, window_begin, window_end, result, count, row_idx, WindowSegmentTreePart::FULL); + part->Evaluate(gtstate, window_begin, window_end, nullptr, result, count, row_idx, WindowSegmentTreePart::FULL); } part->Finalize(result, count); } void WindowSegmentTreePart::Evaluate(const WindowSegmentTreeGlobalState &tree, const idx_t *begins, const idx_t *ends, - Vector &result, idx_t count, idx_t row_idx, FramePart frame_part) { + const idx_t *bounds, Vector &result, idx_t count, idx_t row_idx, + FramePart frame_part) { Initialize(count); if (order_insensitive) { // First pass: aggregate the segment tree nodes with sharing - EvaluateUpperLevels(tree, begins, ends, count, row_idx, frame_part); + EvaluateUpperLevels(tree, begins, ends, bounds, count, row_idx, frame_part); // Second pass: aggregate the ragged leaves - EvaluateLeaves(tree, begins, ends, count, row_idx, frame_part, FramePart::FULL); + EvaluateLeaves(tree, begins, ends, bounds, count, row_idx, frame_part, FramePart::FULL); } else { // Evaluate leaves in order - EvaluateLeaves(tree, begins, ends, count, row_idx, frame_part, FramePart::LEFT); - EvaluateUpperLevels(tree, begins, ends, count, row_idx, frame_part); - EvaluateLeaves(tree, begins, ends, count, row_idx, frame_part, FramePart::RIGHT); + EvaluateLeaves(tree, begins, ends, bounds, count, row_idx, frame_part, FramePart::LEFT); + EvaluateUpperLevels(tree, begins, ends, bounds, count, row_idx, frame_part); + EvaluateLeaves(tree, begins, ends, bounds, count, row_idx, frame_part, FramePart::RIGHT); } } @@ -447,13 +463,18 @@ void WindowSegmentTreePart::Initialize(idx_t count) { } void WindowSegmentTreePart::EvaluateUpperLevels(const WindowSegmentTreeGlobalState &tree, const idx_t *begins, - const idx_t *ends, idx_t count, idx_t row_idx, FramePart frame_part) { + const idx_t *ends, const idx_t *bounds, idx_t count, idx_t row_idx, + FramePart frame_part) { auto fdata = FlatVector::GetData(statef); const auto exclude_mode = tree.tree.exclude_mode; const bool begin_on_curr_row = frame_part == FramePart::RIGHT && exclude_mode == WindowExcludeMode::CURRENT_ROW; const bool end_on_curr_row = frame_part == FramePart::LEFT && exclude_mode == WindowExcludeMode::CURRENT_ROW; + // We need the full range of the frame to clamp + auto frame_begins = FrameBegins(begins, ends, bounds, frame_part); + auto frame_ends = FrameEnds(begins, ends, bounds, frame_part); + const auto max_level = tree.levels_flat_start.size() + 1; right_stack.resize(max_level, {0, 0}); @@ -467,8 +488,8 @@ void WindowSegmentTreePart::EvaluateUpperLevels(const WindowSegmentTreeGlobalSta for (idx_t rid = 0, cur_row = row_idx; rid < count; ++rid, ++cur_row) { auto state_ptr = fdata[rid]; - auto begin = begin_on_curr_row ? cur_row + 1 : begins[rid]; - auto end = end_on_curr_row ? cur_row : ends[rid]; + auto begin = MaxValue(begin_on_curr_row ? cur_row + 1 : begins[rid], frame_begins[rid]); + auto end = MinValue(end_on_curr_row ? cur_row : ends[rid], frame_ends[rid]); if (begin >= end) { continue; } @@ -541,8 +562,8 @@ void WindowSegmentTreePart::EvaluateUpperLevels(const WindowSegmentTreeGlobalSta } void WindowSegmentTreePart::EvaluateLeaves(const WindowSegmentTreeGlobalState &tree, const idx_t *begins, - const idx_t *ends, idx_t count, idx_t row_idx, FramePart frame_part, - FramePart leaf_part) { + const idx_t *ends, const idx_t *bounds, idx_t count, idx_t row_idx, + FramePart frame_part, FramePart leaf_part) { auto fdata = FlatVector::GetData(statef); @@ -558,12 +579,19 @@ void WindowSegmentTreePart::EvaluateLeaves(const WindowSegmentTreeGlobalState &t // current row const bool add_curr_row = compute_left && frame_part == FramePart::RIGHT && exclude_mode == WindowExcludeMode::TIES; + // We need the full range of the frame to clamp + auto frame_begins = FrameBegins(begins, ends, bounds, frame_part); + auto frame_ends = FrameEnds(begins, ends, bounds, frame_part); + for (idx_t rid = 0, cur_row = row_idx; rid < count; ++rid, ++cur_row) { auto state_ptr = fdata[rid]; - const auto begin = begin_on_curr_row ? cur_row + 1 : begins[rid]; - const auto end = end_on_curr_row ? cur_row : ends[rid]; - if (add_curr_row) { + const auto frame_begin = frame_begins[rid]; + auto begin = MaxValue(begin_on_curr_row ? cur_row + 1 : begins[rid], frame_begin); + + const auto frame_end = frame_ends[rid]; + auto end = MinValue(end_on_curr_row ? cur_row : ends[rid], frame_end); + if (add_curr_row && frame_begin <= cur_row && cur_row < frame_end) { WindowSegmentValue(tree, 0, cur_row, cur_row + 1, state_ptr); } if (begin >= end) { diff --git a/src/duckdb/src/include/duckdb/common/arrow/arrow_type_extension.hpp b/src/duckdb/src/include/duckdb/common/arrow/arrow_type_extension.hpp index bc2e50c1c..a8fd35bc9 100644 --- a/src/duckdb/src/include/duckdb/common/arrow/arrow_type_extension.hpp +++ b/src/duckdb/src/include/duckdb/common/arrow/arrow_type_extension.hpp @@ -70,6 +70,8 @@ typedef shared_ptr (*get_type_t)(const ArrowSchema &schema, const Arr class ArrowTypeExtension { public: ArrowTypeExtension() {}; + //! This type is not registered, so we just use whatever is the format and hope for the best + explicit ArrowTypeExtension(ArrowExtensionMetadata &extension_metadata, unique_ptr type); //! We either have simple extensions where we only return one type ArrowTypeExtension(string extension_name, string arrow_format, shared_ptr type); ArrowTypeExtension(string vendor_name, string type_name, string arrow_format, diff --git a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp index 5e4e62356..6d22a45dc 100644 --- a/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp +++ b/src/duckdb/src/include/duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp @@ -138,6 +138,8 @@ class CSVSniffer { idx_t LinesSniffed() const; + bool EmptyOrOnlyHeader() const; + private: //! CSV State Machine Cache CSVStateMachineCache &state_machine_cache; diff --git a/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_insert.hpp b/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_insert.hpp index ccb113c4f..04d202af2 100644 --- a/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_insert.hpp +++ b/src/duckdb/src/include/duckdb/execution/operator/persistent/physical_insert.hpp @@ -38,7 +38,7 @@ class InsertGlobalState : public GlobalSinkState { class InsertLocalState : public LocalSinkState { public: public: - InsertLocalState(ClientContext &context, const vector &types, + InsertLocalState(ClientContext &context, const vector &types_p, const vector> &bound_defaults, const vector> &bound_constraints); @@ -47,8 +47,12 @@ class InsertLocalState : public LocalSinkState { TableDeleteState &GetDeleteState(DataTable &table, TableCatalogEntry &table_ref, ClientContext &context); public: - //! The chunk that ends up getting inserted + //! The to-be-inserted chunk. + //! We initialize it lazily, as we need to know which columns will be references and which will be set to their + //! default values. DataChunk insert_chunk; + bool init_insert_chunk = true; + vector types; //! The chunk containing the tuples that become an update (if DO UPDATE) DataChunk update_chunk; ExpressionExecutor default_executor; @@ -170,8 +174,7 @@ class PhysicalInsert : public PhysicalOperator { //! Returns the amount of updated tuples void CreateUpdateChunk(ExecutionContext &context, DataChunk &chunk, TableCatalogEntry &table, Vector &row_ids, DataChunk &result) const; - idx_t OnConflictHandling(TableCatalogEntry &table, ExecutionContext &context, InsertGlobalState &gstate, - InsertLocalState &lstate) const; + idx_t OnConflictHandling(TableCatalogEntry &table, ExecutionContext &context, InsertLocalState &lstate) const; }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/function/table/arrow/arrow_duck_schema.hpp b/src/duckdb/src/include/duckdb/function/table/arrow/arrow_duck_schema.hpp index 6b09f695c..7d92a3437 100644 --- a/src/duckdb/src/include/duckdb/function/table/arrow/arrow_duck_schema.hpp +++ b/src/duckdb/src/include/duckdb/function/table/arrow/arrow_duck_schema.hpp @@ -84,6 +84,7 @@ class ArrowType { } void ThrowIfInvalid() const; + static unique_ptr GetTypeFromFormat(string &format); static unique_ptr GetTypeFromFormat(DBConfig &config, ArrowSchema &schema, string &format); static unique_ptr GetTypeFromSchema(DBConfig &config, ArrowSchema &schema); diff --git a/src/duckdb/src/include/duckdb/function/table/system_functions.hpp b/src/duckdb/src/include/duckdb/function/table/system_functions.hpp index 05e3485e3..c339b386d 100644 --- a/src/duckdb/src/include/duckdb/function/table/system_functions.hpp +++ b/src/duckdb/src/include/duckdb/function/table/system_functions.hpp @@ -103,6 +103,10 @@ struct DuckDBOptimizersFun { static void RegisterFunction(BuiltinFunctions &set); }; +struct DuckDBSecretTypesFun { + static void RegisterFunction(BuiltinFunctions &set); +}; + struct DuckDBSequencesFun { static void RegisterFunction(BuiltinFunctions &set); }; diff --git a/src/duckdb/src/include/duckdb/function/window/window_boundaries_state.hpp b/src/duckdb/src/include/duckdb/function/window/window_boundaries_state.hpp index 35e0fdb68..2748bc7a0 100644 --- a/src/duckdb/src/include/duckdb/function/window/window_boundaries_state.hpp +++ b/src/duckdb/src/include/duckdb/function/window/window_boundaries_state.hpp @@ -113,9 +113,9 @@ struct WindowBoundariesState { void ValidEnd(DataChunk &bounds, idx_t row_idx, const idx_t count, bool is_jump, const ValidityMask &partition_mask, const ValidityMask &order_mask, optional_ptr range); void FrameBegin(DataChunk &bounds, idx_t row_idx, const idx_t count, WindowInputExpression &boundary_begin, - optional_ptr range); + const ValidityMask &order_mask, optional_ptr range); void FrameEnd(DataChunk &bounds, idx_t row_idx, const idx_t count, WindowInputExpression &boundary_end, - optional_ptr range); + const ValidityMask &order_mask, optional_ptr range); static void ClampFrame(const idx_t count, idx_t *values, const idx_t *begin, const idx_t *end) { for (idx_t i = 0; i < count; ++i) { diff --git a/src/duckdb/src/include/duckdb/main/config.hpp b/src/duckdb/src/include/duckdb/main/config.hpp index ed88f334a..36408cc86 100644 --- a/src/duckdb/src/include/duckdb/main/config.hpp +++ b/src/duckdb/src/include/duckdb/main/config.hpp @@ -202,6 +202,8 @@ struct DBConfigOptions { 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; + //! The set of disabled compression methods (default empty) + set disabled_compression_methods; //! Force a specific bitpacking mode to be used when using the bitpacking compression method BitpackingMode force_bitpacking_mode = BitpackingMode::AUTO; //! Debug setting for window aggregation mode: (window, combine, separate) diff --git a/src/duckdb/src/include/duckdb/main/extension_entries.hpp b/src/duckdb/src/include/duckdb/main/extension_entries.hpp index 037e92272..ab0465210 100644 --- a/src/duckdb/src/include/duckdb/main/extension_entries.hpp +++ b/src/duckdb/src/include/duckdb/main/extension_entries.hpp @@ -981,6 +981,7 @@ static constexpr ExtensionEntry EXTENSION_SETTINGS[] = { {"s3_use_ssl", "httpfs"}, {"sqlite_all_varchar", "sqlite_scanner"}, {"timezone", "icu"}, + {"unsafe_enable_version_guessing", "iceberg"}, }; // END_OF_EXTENSION_SETTINGS // Note: these are currently hardcoded in scripts/generate_extensions_function.py diff --git a/src/duckdb/src/include/duckdb/main/secret/secret.hpp b/src/duckdb/src/include/duckdb/main/secret/secret.hpp index ee721d7f8..7d71522cb 100644 --- a/src/duckdb/src/include/duckdb/main/secret/secret.hpp +++ b/src/duckdb/src/include/duckdb/main/secret/secret.hpp @@ -78,6 +78,8 @@ struct SecretType { secret_deserializer_t deserializer; //! Provider to use when non is specified string default_provider; + //! The extension that registered this secret type + string extension; }; enum class SecretSerializationType : uint8_t { 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 7b1549ec2..69f03a663 100644 --- a/src/duckdb/src/include/duckdb/main/secret/secret_manager.hpp +++ b/src/duckdb/src/include/duckdb/main/secret/secret_manager.hpp @@ -135,6 +135,9 @@ class SecretManager { //! List all secrets from all secret storages DUCKDB_API vector AllSecrets(CatalogTransaction transaction); + //! List all secret types + DUCKDB_API vector AllSecretTypes(); + //! Secret Manager settings DUCKDB_API virtual void SetEnablePersistentSecrets(bool enabled); DUCKDB_API virtual void ResetEnablePersistentSecrets(); diff --git a/src/duckdb/src/include/duckdb/main/settings.hpp b/src/duckdb/src/include/duckdb/main/settings.hpp index e5fe24520..b9c979dca 100644 --- a/src/duckdb/src/include/duckdb/main/settings.hpp +++ b/src/duckdb/src/include/duckdb/main/settings.hpp @@ -419,6 +419,16 @@ struct DefaultSecretStorageSetting { static Value GetSetting(const ClientContext &context); }; +struct DisabledCompressionMethodsSetting { + using RETURN_TYPE = string; + static constexpr const char *Name = "disabled_compression_methods"; + static constexpr const char *Description = "Disable a specific set of compression methods (comma separated)"; + 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); +}; + struct DisabledFilesystemsSetting { using RETURN_TYPE = string; static constexpr const char *Name = "disabled_filesystems"; diff --git a/src/duckdb/src/include/duckdb/parser/expression/window_expression.hpp b/src/duckdb/src/include/duckdb/parser/expression/window_expression.hpp index e41f4ad82..cc5e9c61f 100644 --- a/src/duckdb/src/include/duckdb/parser/expression/window_expression.hpp +++ b/src/duckdb/src/include/duckdb/parser/expression/window_expression.hpp @@ -22,7 +22,10 @@ enum class WindowBoundary : uint8_t { EXPR_PRECEDING_ROWS = 5, EXPR_FOLLOWING_ROWS = 6, EXPR_PRECEDING_RANGE = 7, - EXPR_FOLLOWING_RANGE = 8 + EXPR_FOLLOWING_RANGE = 8, + CURRENT_ROW_GROUPS = 9, + EXPR_PRECEDING_GROUPS = 10, + EXPR_FOLLOWING_GROUPS = 11 }; //! Represents the window exclusion mode @@ -92,6 +95,17 @@ class WindowExpression : public ParsedExpression { static ExpressionType WindowToExpressionType(string &fun_name); public: + static inline string ToUnits(const WindowBoundary boundary, const WindowBoundary rows, const WindowBoundary range, + const WindowBoundary groups) { + if (boundary == rows) { + return "ROWS"; + } else if (boundary == range) { + return "RANGE"; + } else { + return "GROUPS"; + } + } + template static string ToString(const T &entry, const string &schema, const string &function_name) { // Start with function call @@ -156,8 +170,10 @@ class WindowExpression : public ParsedExpression { switch (entry.start) { case WindowBoundary::CURRENT_ROW_RANGE: case WindowBoundary::CURRENT_ROW_ROWS: + case WindowBoundary::CURRENT_ROW_GROUPS: from = "CURRENT ROW"; - units = (entry.start == WindowBoundary::CURRENT_ROW_RANGE) ? "RANGE" : "ROWS"; + units = ToUnits(entry.start, WindowBoundary::CURRENT_ROW_ROWS, WindowBoundary::CURRENT_ROW_RANGE, + WindowBoundary::CURRENT_ROW_GROUPS); break; case WindowBoundary::UNBOUNDED_PRECEDING: if (entry.end != WindowBoundary::CURRENT_ROW_RANGE) { @@ -166,15 +182,20 @@ class WindowExpression : public ParsedExpression { break; case WindowBoundary::EXPR_PRECEDING_ROWS: case WindowBoundary::EXPR_PRECEDING_RANGE: + case WindowBoundary::EXPR_PRECEDING_GROUPS: from = entry.start_expr->ToString() + " PRECEDING"; - units = (entry.start == WindowBoundary::EXPR_PRECEDING_RANGE) ? "RANGE" : "ROWS"; + units = ToUnits(entry.start, WindowBoundary::EXPR_PRECEDING_ROWS, WindowBoundary::EXPR_PRECEDING_RANGE, + WindowBoundary::EXPR_PRECEDING_GROUPS); break; case WindowBoundary::EXPR_FOLLOWING_ROWS: case WindowBoundary::EXPR_FOLLOWING_RANGE: + case WindowBoundary::EXPR_FOLLOWING_GROUPS: from = entry.start_expr->ToString() + " FOLLOWING"; - units = (entry.start == WindowBoundary::EXPR_FOLLOWING_RANGE) ? "RANGE" : "ROWS"; + units = ToUnits(entry.start, WindowBoundary::EXPR_FOLLOWING_ROWS, WindowBoundary::EXPR_FOLLOWING_RANGE, + WindowBoundary::EXPR_FOLLOWING_GROUPS); break; - default: + case WindowBoundary::UNBOUNDED_FOLLOWING: + case WindowBoundary::INVALID: throw InternalException("Unrecognized FROM in WindowExpression"); } @@ -187,8 +208,10 @@ class WindowExpression : public ParsedExpression { } break; case WindowBoundary::CURRENT_ROW_ROWS: + case WindowBoundary::CURRENT_ROW_GROUPS: to = "CURRENT ROW"; - units = "ROWS"; + units = ToUnits(entry.end, WindowBoundary::CURRENT_ROW_ROWS, WindowBoundary::CURRENT_ROW_RANGE, + WindowBoundary::CURRENT_ROW_GROUPS); break; case WindowBoundary::UNBOUNDED_PRECEDING: to = "UNBOUNDED PRECEDING"; @@ -198,15 +221,19 @@ class WindowExpression : public ParsedExpression { break; case WindowBoundary::EXPR_PRECEDING_ROWS: case WindowBoundary::EXPR_PRECEDING_RANGE: + case WindowBoundary::EXPR_PRECEDING_GROUPS: to = entry.end_expr->ToString() + " PRECEDING"; - units = (entry.end == WindowBoundary::EXPR_PRECEDING_RANGE) ? "RANGE" : "ROWS"; + units = ToUnits(entry.end, WindowBoundary::EXPR_PRECEDING_ROWS, WindowBoundary::EXPR_PRECEDING_RANGE, + WindowBoundary::EXPR_PRECEDING_GROUPS); break; case WindowBoundary::EXPR_FOLLOWING_ROWS: case WindowBoundary::EXPR_FOLLOWING_RANGE: + case WindowBoundary::EXPR_FOLLOWING_GROUPS: to = entry.end_expr->ToString() + " FOLLOWING"; - units = (entry.end == WindowBoundary::EXPR_FOLLOWING_RANGE) ? "RANGE" : "ROWS"; + units = ToUnits(entry.end, WindowBoundary::EXPR_FOLLOWING_ROWS, WindowBoundary::EXPR_FOLLOWING_RANGE, + WindowBoundary::EXPR_FOLLOWING_GROUPS); break; - default: + case WindowBoundary::INVALID: throw InternalException("Unrecognized TO in WindowExpression"); } if (entry.exclude_clause != WindowExcludeMode::NO_OTHER) { diff --git a/src/duckdb/src/include/duckdb/parser/query_node/set_operation_node.hpp b/src/duckdb/src/include/duckdb/parser/query_node/set_operation_node.hpp index 02f2d371d..de36f3cad 100644 --- a/src/duckdb/src/include/duckdb/parser/query_node/set_operation_node.hpp +++ b/src/duckdb/src/include/duckdb/parser/query_node/set_operation_node.hpp @@ -20,8 +20,7 @@ class SetOperationNode : public QueryNode { static constexpr const QueryNodeType TYPE = QueryNodeType::SET_OPERATION_NODE; public: - SetOperationNode() : QueryNode(QueryNodeType::SET_OPERATION_NODE) { - } + SetOperationNode(); //! The type of set operation SetOperationType setop_type = SetOperationType::NONE; @@ -49,6 +48,13 @@ class SetOperationNode : public QueryNode { void Serialize(Serializer &serializer) const override; static unique_ptr Deserialize(Deserializer &source); + +public: + // these methods exist for forwards/backwards compatibility of (de)serialization + SetOperationNode(SetOperationType setop_type, unique_ptr left, unique_ptr right, + vector> children, bool setop_all); + + vector> SerializeChildNodes() const; }; } // namespace duckdb diff --git a/src/duckdb/src/main/config.cpp b/src/duckdb/src/main/config.cpp index 52a9ac2da..a573529e5 100644 --- a/src/duckdb/src/main/config.cpp +++ b/src/duckdb/src/main/config.cpp @@ -92,6 +92,7 @@ static const ConfigurationOption internal_options[] = { DUCKDB_GLOBAL_ALIAS("null_order", DefaultNullOrderSetting), DUCKDB_GLOBAL(DefaultOrderSetting), DUCKDB_GLOBAL(DefaultSecretStorageSetting), + DUCKDB_GLOBAL(DisabledCompressionMethodsSetting), DUCKDB_GLOBAL(DisabledFilesystemsSetting), DUCKDB_GLOBAL(DisabledLogTypes), DUCKDB_GLOBAL(DisabledOptimizersSetting), diff --git a/src/duckdb/src/main/secret/secret_manager.cpp b/src/duckdb/src/main/secret/secret_manager.cpp index 191cf1f56..d49d56030 100644 --- a/src/duckdb/src/main/secret/secret_manager.cpp +++ b/src/duckdb/src/main/secret/secret_manager.cpp @@ -489,6 +489,17 @@ vector SecretManager::AllSecrets(CatalogTransaction transaction) { return result; } +vector SecretManager::AllSecretTypes() { + unique_lock lck(manager_lock); + vector result; + + for (const auto &secret : secret_types) { + result.push_back(secret.second); + } + + return result; +} + void SecretManager::ThrowOnSettingChangeIfInitialized() { if (initialized) { throw InvalidInputException( diff --git a/src/duckdb/src/main/settings/custom_settings.cpp b/src/duckdb/src/main/settings/custom_settings.cpp index 68b36362c..4471021b4 100644 --- a/src/duckdb/src/main/settings/custom_settings.cpp +++ b/src/duckdb/src/main/settings/custom_settings.cpp @@ -499,6 +499,50 @@ Value DefaultSecretStorageSetting::GetSetting(const ClientContext &context) { return config.secret_manager->DefaultStorage(); } +//===----------------------------------------------------------------------===// +// Disabled Compression Methods +//===----------------------------------------------------------------------===// +void DisabledCompressionMethodsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { + auto list = StringUtil::Split(input.ToString(), ","); + set disabled_compression_methods; + for (auto &entry : list) { + auto param = StringUtil::Lower(entry); + StringUtil::Trim(param); + if (param.empty()) { + continue; + } + if (param == "none") { + 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); + } + disabled_compression_methods.insert(compression_type); + } + config.options.disabled_compression_methods = std::move(disabled_compression_methods); +} + +void DisabledCompressionMethodsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { + config.options.disabled_compression_methods = DBConfig().options.disabled_compression_methods; +} + +Value DisabledCompressionMethodsSetting::GetSetting(const ClientContext &context) { + auto &config = DBConfig::GetConfig(context); + string result; + for (auto &optimizer : config.options.disabled_compression_methods) { + if (!result.empty()) { + result += ","; + } + result += CompressionTypeToString(optimizer); + } + return Value(result); +} + //===----------------------------------------------------------------------===// // Disabled Filesystems //===----------------------------------------------------------------------===// diff --git a/src/duckdb/src/optimizer/filter_pushdown.cpp b/src/duckdb/src/optimizer/filter_pushdown.cpp index c7962b714..883885178 100644 --- a/src/duckdb/src/optimizer/filter_pushdown.cpp +++ b/src/duckdb/src/optimizer/filter_pushdown.cpp @@ -3,6 +3,7 @@ #include "duckdb/optimizer/optimizer.hpp" #include "duckdb/planner/expression_iterator.hpp" #include "duckdb/planner/operator/logical_comparison_join.hpp" +#include "duckdb/planner/operator/logical_aggregate.hpp" #include "duckdb/planner/operator/logical_filter.hpp" #include "duckdb/planner/operator/logical_join.hpp" #include "duckdb/planner/operator/logical_projection.hpp" @@ -20,7 +21,8 @@ void FilterPushdown::CheckMarkToSemi(LogicalOperator &op, unordered_set & if (join.join_type != JoinType::MARK) { break; } - // if the projected table bindings include the mark join index, + // if an operator above the mark join includes the mark join index, + // then the mark join cannot be converted to a semi join if (table_bindings.find(join.mark_index) != table_bindings.end()) { join.convert_mark_to_semi = false; } @@ -38,20 +40,45 @@ void FilterPushdown::CheckMarkToSemi(LogicalOperator &op, unordered_set & for (auto &binding : proj_bindings) { auto col_index = binding.column_index; auto &expr = proj.expressions.at(col_index); - vector bindings_to_keep; ExpressionIterator::EnumerateExpression(expr, [&](Expression &child) { if (child.GetExpressionClass() == ExpressionClass::BOUND_COLUMN_REF) { auto &col_ref = child.Cast(); - bindings_to_keep.push_back(col_ref.binding); + new_table_bindings.insert(col_ref.binding.table_index); } }); - for (auto &expr_binding : bindings_to_keep) { - new_table_bindings.insert(expr_binding.table_index); - } table_bindings = new_table_bindings; } break; } + // It's possible a mark join index makes its way into a group by as the grouping index + // when that happens we need to keep track of it to make sure we do not convert a mark join to semi. + // see filter_pushdown_into_subquery. + case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY: { + auto &aggr = op.Cast(); + auto aggr_bindings = aggr.GetColumnBindings(); + vector bindings_to_keep; + for (auto &expr : aggr.groups) { + ExpressionIterator::EnumerateExpression(expr, [&](Expression &child) { + if (child.GetExpressionClass() == ExpressionClass::BOUND_COLUMN_REF) { + auto &col_ref = child.Cast(); + bindings_to_keep.push_back(col_ref.binding); + } + }); + } + for (auto &expr : aggr.expressions) { + ExpressionIterator::EnumerateExpression(expr, [&](Expression &child) { + if (child.GetExpressionClass() == ExpressionClass::BOUND_COLUMN_REF) { + auto &col_ref = child.Cast(); + bindings_to_keep.push_back(col_ref.binding); + } + }); + } + table_bindings = unordered_set(); + for (auto &expr_binding : bindings_to_keep) { + table_bindings.insert(expr_binding.table_index); + } + break; + } default: break; } 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 5b444cf60..9a8168a45 100644 --- a/src/duckdb/src/parser/query_node/set_operation_node.cpp +++ b/src/duckdb/src/parser/query_node/set_operation_node.cpp @@ -5,6 +5,9 @@ namespace duckdb { +SetOperationNode::SetOperationNode() : QueryNode(QueryNodeType::SET_OPERATION_NODE) { +} + string SetOperationNode::ToString() const { string result; result = cte_map.ToString(); @@ -63,4 +66,50 @@ unique_ptr SetOperationNode::Copy() const { return std::move(result); } +SetOperationNode::SetOperationNode(SetOperationType setop_type, unique_ptr left, unique_ptr right, + vector> children, bool setop_all) + : QueryNode(QueryNodeType::SET_OPERATION_NODE), setop_type(setop_type), setop_all(setop_all) { + if (left && right) { + // simple case - left/right are supplied + this->left = std::move(left); + this->right = std::move(right); + return; + } + if (children.size() == 2) { + this->left = std::move(children[0]); + this->right = std::move(children[1]); + } + // we have multiple children - we need to construct a tree of set operation nodes + if (children.size() <= 1) { + throw SerializationException("Set Operation requires at least 2 children"); + } + if (setop_type != SetOperationType::UNION) { + throw SerializationException("Multiple children in set-operations are only supported for UNION"); + } + // construct a balanced tree from the union + while (children.size() > 2) { + vector> new_children; + for (idx_t i = 0; i < children.size(); i += 2) { + if (i + 1 == children.size()) { + new_children.push_back(std::move(children[i])); + } else { + vector> empty_children; + auto setop_node = + make_uniq(setop_type, std::move(children[i]), std::move(children[i + 1]), + std::move(empty_children), setop_all); + new_children.push_back(std::move(setop_node)); + } + } + children = std::move(new_children); + } + // two children left - fill in the left/right of this node + this->left = std::move(children[0]); + this->right = std::move(children[1]); +} + +vector> SetOperationNode::SerializeChildNodes() const { + // we always serialize children as left/right currently + return vector>(); +} + } // namespace duckdb diff --git a/src/duckdb/src/parser/transform/expression/transform_function.cpp b/src/duckdb/src/parser/transform/expression/transform_function.cpp index e410b7049..d33bf00d0 100644 --- a/src/duckdb/src/parser/transform/expression/transform_function.cpp +++ b/src/duckdb/src/parser/transform/expression/transform_function.cpp @@ -35,6 +35,18 @@ void Transformer::TransformWindowDef(duckdb_libpgquery::PGWindowDef &window_spec } } +static inline WindowBoundary TransformFrameOption(const int frameOptions, const WindowBoundary rows, + const WindowBoundary range, const WindowBoundary groups) { + + if (frameOptions & FRAMEOPTION_RANGE) { + return range; + } else if (frameOptions & FRAMEOPTION_GROUPS) { + return groups; + } else { + return rows; + } +} + void Transformer::TransformWindowFrame(duckdb_libpgquery::PGWindowDef &window_spec, WindowExpression &expr) { // finally: specifics of bounds expr.start_expr = TransformExpression(window_spec.startOffset); @@ -46,28 +58,30 @@ void Transformer::TransformWindowFrame(duckdb_libpgquery::PGWindowDef &window_sp "Window frames starting with unbounded following or ending in unbounded preceding make no sense"); } - if (window_spec.frameOptions & FRAMEOPTION_GROUPS) { - throw ParserException("GROUPS mode for window functions is not implemented yet"); - } - const bool rangeMode = (window_spec.frameOptions & FRAMEOPTION_RANGE) != 0; if (window_spec.frameOptions & FRAMEOPTION_START_UNBOUNDED_PRECEDING) { expr.start = WindowBoundary::UNBOUNDED_PRECEDING; } else if (window_spec.frameOptions & FRAMEOPTION_START_OFFSET_PRECEDING) { - expr.start = rangeMode ? WindowBoundary::EXPR_PRECEDING_RANGE : WindowBoundary::EXPR_PRECEDING_ROWS; + expr.start = TransformFrameOption(window_spec.frameOptions, WindowBoundary::EXPR_PRECEDING_ROWS, + WindowBoundary::EXPR_PRECEDING_RANGE, WindowBoundary::EXPR_PRECEDING_GROUPS); } else if (window_spec.frameOptions & FRAMEOPTION_START_OFFSET_FOLLOWING) { - expr.start = rangeMode ? WindowBoundary::EXPR_FOLLOWING_RANGE : WindowBoundary::EXPR_FOLLOWING_ROWS; + expr.start = TransformFrameOption(window_spec.frameOptions, WindowBoundary::EXPR_FOLLOWING_ROWS, + WindowBoundary::EXPR_FOLLOWING_RANGE, WindowBoundary::EXPR_FOLLOWING_GROUPS); } else if (window_spec.frameOptions & FRAMEOPTION_START_CURRENT_ROW) { - expr.start = rangeMode ? WindowBoundary::CURRENT_ROW_RANGE : WindowBoundary::CURRENT_ROW_ROWS; + expr.start = TransformFrameOption(window_spec.frameOptions, WindowBoundary::CURRENT_ROW_ROWS, + WindowBoundary::CURRENT_ROW_RANGE, WindowBoundary::CURRENT_ROW_GROUPS); } if (window_spec.frameOptions & FRAMEOPTION_END_UNBOUNDED_FOLLOWING) { expr.end = WindowBoundary::UNBOUNDED_FOLLOWING; } else if (window_spec.frameOptions & FRAMEOPTION_END_OFFSET_PRECEDING) { - expr.end = rangeMode ? WindowBoundary::EXPR_PRECEDING_RANGE : WindowBoundary::EXPR_PRECEDING_ROWS; + expr.end = TransformFrameOption(window_spec.frameOptions, WindowBoundary::EXPR_PRECEDING_ROWS, + WindowBoundary::EXPR_PRECEDING_RANGE, WindowBoundary::EXPR_PRECEDING_GROUPS); } else if (window_spec.frameOptions & FRAMEOPTION_END_OFFSET_FOLLOWING) { - expr.end = rangeMode ? WindowBoundary::EXPR_FOLLOWING_RANGE : WindowBoundary::EXPR_FOLLOWING_ROWS; + expr.end = TransformFrameOption(window_spec.frameOptions, WindowBoundary::EXPR_FOLLOWING_ROWS, + WindowBoundary::EXPR_FOLLOWING_RANGE, WindowBoundary::EXPR_FOLLOWING_GROUPS); } else if (window_spec.frameOptions & FRAMEOPTION_END_CURRENT_ROW) { - expr.end = rangeMode ? WindowBoundary::CURRENT_ROW_RANGE : WindowBoundary::CURRENT_ROW_ROWS; + expr.end = TransformFrameOption(window_spec.frameOptions, WindowBoundary::CURRENT_ROW_ROWS, + WindowBoundary::CURRENT_ROW_RANGE, WindowBoundary::CURRENT_ROW_GROUPS); } D_ASSERT(expr.start != WindowBoundary::INVALID && expr.end != WindowBoundary::INVALID); diff --git a/src/duckdb/src/planner/expression_binder/index_binder.cpp b/src/duckdb/src/planner/expression_binder/index_binder.cpp index 950edb6e6..17707173c 100644 --- a/src/duckdb/src/planner/expression_binder/index_binder.cpp +++ b/src/duckdb/src/planner/expression_binder/index_binder.cpp @@ -62,6 +62,7 @@ void IndexBinder::InitCreateIndexInfo(LogicalGet &get, CreateIndexInfo &info, co info.scan_types.emplace_back(LogicalType::ROW_TYPE); info.names = get.names; info.schema = schema; + info.catalog = get.GetTable()->catalog.GetName(); get.AddColumnId(COLUMN_IDENTIFIER_ROW_ID); } diff --git a/src/duckdb/src/storage/serialization/serialize_query_node.cpp b/src/duckdb/src/storage/serialization/serialize_query_node.cpp index cc8280b2d..4aa4ebb77 100644 --- a/src/duckdb/src/storage/serialization/serialize_query_node.cpp +++ b/src/duckdb/src/storage/serialization/serialize_query_node.cpp @@ -110,14 +110,16 @@ void SetOperationNode::Serialize(Serializer &serializer) const { serializer.WritePropertyWithDefault>(201, "left", left); serializer.WritePropertyWithDefault>(202, "right", right); serializer.WritePropertyWithDefault(203, "setop_all", setop_all, true); + serializer.WritePropertyWithDefault>>(204, "children", SerializeChildNodes()); } unique_ptr SetOperationNode::Deserialize(Deserializer &deserializer) { - auto result = duckdb::unique_ptr(new SetOperationNode()); - deserializer.ReadProperty(200, "setop_type", result->setop_type); - deserializer.ReadPropertyWithDefault>(201, "left", result->left); - deserializer.ReadPropertyWithDefault>(202, "right", result->right); - deserializer.ReadPropertyWithExplicitDefault(203, "setop_all", result->setop_all, true); + auto setop_type = deserializer.ReadProperty(200, "setop_type"); + auto left = deserializer.ReadPropertyWithDefault>(201, "left"); + auto right = deserializer.ReadPropertyWithDefault>(202, "right"); + auto setop_all = deserializer.ReadPropertyWithExplicitDefault(203, "setop_all", true); + auto children = deserializer.ReadPropertyWithDefault>>(204, "children"); + auto result = duckdb::unique_ptr(new SetOperationNode(setop_type, std::move(left), std::move(right), std::move(children), setop_all)); return std::move(result); } diff --git a/src/duckdb/src/storage/table/row_group_collection.cpp b/src/duckdb/src/storage/table/row_group_collection.cpp index 90a7236ff..a16764419 100644 --- a/src/duckdb/src/storage/table/row_group_collection.cpp +++ b/src/duckdb/src/storage/table/row_group_collection.cpp @@ -656,64 +656,101 @@ void RowGroupCollection::Update(TransactionData transaction, row_t *ids, const v void RowGroupCollection::RemoveFromIndexes(TableIndexList &indexes, Vector &row_identifiers, idx_t count) { auto row_ids = FlatVector::GetData(row_identifiers); - // initialize the fetch state - // FIXME: we do not need to fetch all columns, only the columns required by the indices! - TableScanState state; + // Collect all indexed columns. + unordered_set indexed_column_id_set; + indexes.Scan([&](Index &index) { + D_ASSERT(index.IsBound()); + auto &set = index.GetColumnIdSet(); + indexed_column_id_set.insert(set.begin(), set.end()); + return false; + }); vector column_ids; - column_ids.reserve(types.size()); - for (idx_t i = 0; i < types.size(); i++) { - column_ids.emplace_back(i); + for (auto &col : indexed_column_id_set) { + column_ids.emplace_back(col); } + sort(column_ids.begin(), column_ids.end()); + + vector column_types; + for (auto &col : column_ids) { + column_types.push_back(types[col.GetPrimaryIndex()]); + } + + // Initialize the fetch state. Only use indexed columns. + TableScanState state; state.Initialize(std::move(column_ids)); state.table_state.max_row = row_start + total_rows; - // initialize the fetch chunk - DataChunk result; - result.Initialize(GetAllocator(), types); + // Used for scanning data. Only contains the indexed columns. + DataChunk fetch_chunk; + fetch_chunk.Initialize(GetAllocator(), column_types); + + // Used for index value removal. + // Contains all columns but only initializes indexed ones. + DataChunk result_chunk; + auto fetched_columns = vector(types.size(), false); + result_chunk.Initialize(GetAllocator(), types, fetched_columns); + // Now set all to-be-fetched columns. + for (auto &col : indexed_column_id_set) { + fetched_columns[col] = true; + } + + // Iterate over the row ids. SelectionVector sel(STANDARD_VECTOR_SIZE); - // now iterate over the row ids for (idx_t r = 0; r < count;) { - result.Reset(); - // figure out which row_group to fetch from + fetch_chunk.Reset(); + result_chunk.Reset(); + + // Figure out which row_group to fetch from. auto row_id = row_ids[r]; auto row_group = row_groups->GetSegment(UnsafeNumericCast(row_id)); auto row_group_vector_idx = (UnsafeNumericCast(row_id) - row_group->start) / STANDARD_VECTOR_SIZE; auto base_row_id = row_group_vector_idx * STANDARD_VECTOR_SIZE + row_group->start; - // fetch the current vector + // Fetch the current vector into fetch_chunk. state.table_state.Initialize(GetTypes()); row_group->InitializeScanWithOffset(state.table_state, row_group_vector_idx); - row_group->ScanCommitted(state.table_state, result, TableScanType::TABLE_SCAN_COMMITTED_ROWS); - result.Verify(); + row_group->ScanCommitted(state.table_state, fetch_chunk, TableScanType::TABLE_SCAN_COMMITTED_ROWS); + fetch_chunk.Verify(); - // check for any remaining row ids if they also fall into this vector - // we try to fetch handle as many rows as possible at the same time + // Check for any remaining row ids, if they also fall into this vector. + // We try to fetch as many rows as possible at the same time. idx_t sel_count = 0; for (; r < count; r++) { idx_t current_row = idx_t(row_ids[r]); - if (current_row < base_row_id || current_row >= base_row_id + result.size()) { - // this row-id does not fall into the current chunk - break + if (current_row < base_row_id || current_row >= base_row_id + fetch_chunk.size()) { + // This row id does not fall into the current chunk. break; } auto row_in_vector = current_row - base_row_id; - D_ASSERT(row_in_vector < result.size()); + D_ASSERT(row_in_vector < fetch_chunk.size()); sel.set_index(sel_count++, row_in_vector); } D_ASSERT(sel_count > 0); - // slice the vector with all rows that are present in this vector and erase from the index - result.Slice(sel, sel_count); + // Reference the necessary columns of the fetch_chunk. + idx_t fetch_idx = 0; + for (idx_t j = 0; j < types.size(); j++) { + if (fetched_columns[j]) { + result_chunk.data[j].Reference(fetch_chunk.data[fetch_idx++]); + continue; + } + result_chunk.data[j].Reference(Value(types[j])); + } + result_chunk.SetCardinality(fetch_chunk); + + // Slice the vector with all rows that are present in this vector. + // Then, erase all values from the indexes. + result_chunk.Slice(sel, sel_count); indexes.Scan([&](Index &index) { if (index.IsBound()) { - index.Cast().Delete(result, row_identifiers); - } else { - throw MissingExtensionException( - "Cannot delete from index '%s', unknown index type '%s'. You need to load the " - "extension that provides this index type before table '%s' can be modified.", - index.GetIndexName(), index.GetIndexType(), info->GetTableName()); + index.Cast().Delete(result_chunk, row_identifiers); + return false; } - return false; + throw MissingExtensionException( + "Cannot delete from index '%s', unknown index type '%s'. You need to load the " + "extension that provides this index type before table '%s' can be modified.", + index.GetIndexName(), index.GetIndexType(), info->GetTableName()); }); } } diff --git a/src/duckdb/ub_extension_core_functions_aggregate_distributive.cpp b/src/duckdb/ub_extension_core_functions_aggregate_distributive.cpp index f8c552db1..22a9ac797 100644 --- a/src/duckdb/ub_extension_core_functions_aggregate_distributive.cpp +++ b/src/duckdb/ub_extension_core_functions_aggregate_distributive.cpp @@ -1,20 +1,20 @@ -#include "extension/core_functions/aggregate/distributive/skew.cpp" +#include "extension/core_functions/aggregate/distributive/kurtosis.cpp" -#include "extension/core_functions/aggregate/distributive/bool.cpp" +#include "extension/core_functions/aggregate/distributive/string_agg.cpp" -#include "extension/core_functions/aggregate/distributive/bitstring_agg.cpp" +#include "extension/core_functions/aggregate/distributive/sum.cpp" -#include "extension/core_functions/aggregate/distributive/bitagg.cpp" +#include "extension/core_functions/aggregate/distributive/arg_min_max.cpp" -#include "extension/core_functions/aggregate/distributive/kurtosis.cpp" +#include "extension/core_functions/aggregate/distributive/approx_count.cpp" -#include "extension/core_functions/aggregate/distributive/sum.cpp" +#include "extension/core_functions/aggregate/distributive/skew.cpp" -#include "extension/core_functions/aggregate/distributive/arg_min_max.cpp" +#include "extension/core_functions/aggregate/distributive/bitagg.cpp" -#include "extension/core_functions/aggregate/distributive/product.cpp" +#include "extension/core_functions/aggregate/distributive/bitstring_agg.cpp" -#include "extension/core_functions/aggregate/distributive/string_agg.cpp" +#include "extension/core_functions/aggregate/distributive/product.cpp" -#include "extension/core_functions/aggregate/distributive/approx_count.cpp" +#include "extension/core_functions/aggregate/distributive/bool.cpp" diff --git a/src/duckdb/ub_extension_core_functions_aggregate_holistic.cpp b/src/duckdb/ub_extension_core_functions_aggregate_holistic.cpp index 2e18fa37e..7ee6f047a 100644 --- a/src/duckdb/ub_extension_core_functions_aggregate_holistic.cpp +++ b/src/duckdb/ub_extension_core_functions_aggregate_holistic.cpp @@ -1,12 +1,12 @@ -#include "extension/core_functions/aggregate/holistic/mad.cpp" +#include "extension/core_functions/aggregate/holistic/approx_top_k.cpp" #include "extension/core_functions/aggregate/holistic/quantile.cpp" #include "extension/core_functions/aggregate/holistic/reservoir_quantile.cpp" -#include "extension/core_functions/aggregate/holistic/approximate_quantile.cpp" +#include "extension/core_functions/aggregate/holistic/mad.cpp" -#include "extension/core_functions/aggregate/holistic/approx_top_k.cpp" +#include "extension/core_functions/aggregate/holistic/approximate_quantile.cpp" #include "extension/core_functions/aggregate/holistic/mode.cpp" diff --git a/src/duckdb/ub_extension_core_functions_aggregate_nested.cpp b/src/duckdb/ub_extension_core_functions_aggregate_nested.cpp index 8f3f5452f..9d9f036b7 100644 --- a/src/duckdb/ub_extension_core_functions_aggregate_nested.cpp +++ b/src/duckdb/ub_extension_core_functions_aggregate_nested.cpp @@ -1,6 +1,6 @@ #include "extension/core_functions/aggregate/nested/binned_histogram.cpp" -#include "extension/core_functions/aggregate/nested/histogram.cpp" - #include "extension/core_functions/aggregate/nested/list.cpp" +#include "extension/core_functions/aggregate/nested/histogram.cpp" + diff --git a/src/duckdb/ub_extension_core_functions_aggregate_regression.cpp b/src/duckdb/ub_extension_core_functions_aggregate_regression.cpp index 3b2713788..a7d5acb11 100644 --- a/src/duckdb/ub_extension_core_functions_aggregate_regression.cpp +++ b/src/duckdb/ub_extension_core_functions_aggregate_regression.cpp @@ -1,14 +1,14 @@ -#include "extension/core_functions/aggregate/regression/regr_avg.cpp" +#include "extension/core_functions/aggregate/regression/regr_sxy.cpp" #include "extension/core_functions/aggregate/regression/regr_intercept.cpp" -#include "extension/core_functions/aggregate/regression/regr_sxx_syy.cpp" - #include "extension/core_functions/aggregate/regression/regr_count.cpp" -#include "extension/core_functions/aggregate/regression/regr_slope.cpp" - #include "extension/core_functions/aggregate/regression/regr_r2.cpp" -#include "extension/core_functions/aggregate/regression/regr_sxy.cpp" +#include "extension/core_functions/aggregate/regression/regr_avg.cpp" + +#include "extension/core_functions/aggregate/regression/regr_slope.cpp" + +#include "extension/core_functions/aggregate/regression/regr_sxx_syy.cpp" diff --git a/src/duckdb/ub_extension_core_functions_scalar_array.cpp b/src/duckdb/ub_extension_core_functions_scalar_array.cpp index 9b9a475b4..e4f63a369 100644 --- a/src/duckdb/ub_extension_core_functions_scalar_array.cpp +++ b/src/duckdb/ub_extension_core_functions_scalar_array.cpp @@ -1,4 +1,4 @@ -#include "extension/core_functions/scalar/array/array_value.cpp" - #include "extension/core_functions/scalar/array/array_functions.cpp" +#include "extension/core_functions/scalar/array/array_value.cpp" + diff --git a/src/duckdb/ub_extension_core_functions_scalar_date.cpp b/src/duckdb/ub_extension_core_functions_scalar_date.cpp index 11b7e8756..614e5e4e8 100644 --- a/src/duckdb/ub_extension_core_functions_scalar_date.cpp +++ b/src/duckdb/ub_extension_core_functions_scalar_date.cpp @@ -1,20 +1,20 @@ -#include "extension/core_functions/scalar/date/make_date.cpp" - -#include "extension/core_functions/scalar/date/date_trunc.cpp" +#include "extension/core_functions/scalar/date/current.cpp" -#include "extension/core_functions/scalar/date/date_part.cpp" +#include "extension/core_functions/scalar/date/age.cpp" #include "extension/core_functions/scalar/date/date_diff.cpp" -#include "extension/core_functions/scalar/date/age.cpp" +#include "extension/core_functions/scalar/date/date_sub.cpp" + +#include "extension/core_functions/scalar/date/to_interval.cpp" #include "extension/core_functions/scalar/date/time_bucket.cpp" -#include "extension/core_functions/scalar/date/date_sub.cpp" +#include "extension/core_functions/scalar/date/date_trunc.cpp" -#include "extension/core_functions/scalar/date/current.cpp" +#include "extension/core_functions/scalar/date/epoch.cpp" -#include "extension/core_functions/scalar/date/to_interval.cpp" +#include "extension/core_functions/scalar/date/date_part.cpp" -#include "extension/core_functions/scalar/date/epoch.cpp" +#include "extension/core_functions/scalar/date/make_date.cpp" diff --git a/src/duckdb/ub_extension_core_functions_scalar_list.cpp b/src/duckdb/ub_extension_core_functions_scalar_list.cpp index 87d225f95..e3ad42759 100644 --- a/src/duckdb/ub_extension_core_functions_scalar_list.cpp +++ b/src/duckdb/ub_extension_core_functions_scalar_list.cpp @@ -1,22 +1,22 @@ #include "extension/core_functions/scalar/list/flatten.cpp" -#include "extension/core_functions/scalar/list/list_distance.cpp" +#include "extension/core_functions/scalar/list/list_transform.cpp" -#include "extension/core_functions/scalar/list/array_slice.cpp" +#include "extension/core_functions/scalar/list/range.cpp" -#include "extension/core_functions/scalar/list/list_transform.cpp" +#include "extension/core_functions/scalar/list/list_value.cpp" #include "extension/core_functions/scalar/list/list_filter.cpp" -#include "extension/core_functions/scalar/list/list_reduce.cpp" - -#include "extension/core_functions/scalar/list/list_sort.cpp" +#include "extension/core_functions/scalar/list/list_has_any_or_all.cpp" #include "extension/core_functions/scalar/list/list_aggregates.cpp" -#include "extension/core_functions/scalar/list/list_has_any_or_all.cpp" +#include "extension/core_functions/scalar/list/list_distance.cpp" -#include "extension/core_functions/scalar/list/range.cpp" +#include "extension/core_functions/scalar/list/array_slice.cpp" -#include "extension/core_functions/scalar/list/list_value.cpp" +#include "extension/core_functions/scalar/list/list_sort.cpp" + +#include "extension/core_functions/scalar/list/list_reduce.cpp" diff --git a/src/duckdb/ub_extension_core_functions_scalar_map.cpp b/src/duckdb/ub_extension_core_functions_scalar_map.cpp index b191443c0..52bd226f0 100644 --- a/src/duckdb/ub_extension_core_functions_scalar_map.cpp +++ b/src/duckdb/ub_extension_core_functions_scalar_map.cpp @@ -1,14 +1,14 @@ #include "extension/core_functions/scalar/map/map_keys_values.cpp" -#include "extension/core_functions/scalar/map/cardinality.cpp" - -#include "extension/core_functions/scalar/map/map_concat.cpp" - #include "extension/core_functions/scalar/map/map_extract.cpp" #include "extension/core_functions/scalar/map/map_from_entries.cpp" +#include "extension/core_functions/scalar/map/map_entries.cpp" + #include "extension/core_functions/scalar/map/map.cpp" -#include "extension/core_functions/scalar/map/map_entries.cpp" +#include "extension/core_functions/scalar/map/map_concat.cpp" + +#include "extension/core_functions/scalar/map/cardinality.cpp" diff --git a/src/duckdb/ub_extension_core_functions_scalar_string.cpp b/src/duckdb/ub_extension_core_functions_scalar_string.cpp index b57063a4b..f01d70e21 100644 --- a/src/duckdb/ub_extension_core_functions_scalar_string.cpp +++ b/src/duckdb/ub_extension_core_functions_scalar_string.cpp @@ -1,48 +1,48 @@ -#include "extension/core_functions/scalar/string/hex.cpp" +#include "extension/core_functions/scalar/string/starts_with.cpp" -#include "extension/core_functions/scalar/string/unicode.cpp" +#include "extension/core_functions/scalar/string/jaccard.cpp" -#include "extension/core_functions/scalar/string/translate.cpp" +#include "extension/core_functions/scalar/string/levenshtein.cpp" -#include "extension/core_functions/scalar/string/left_right.cpp" +#include "extension/core_functions/scalar/string/damerau_levenshtein.cpp" -#include "extension/core_functions/scalar/string/hamming.cpp" +#include "extension/core_functions/scalar/string/bar.cpp" -#include "extension/core_functions/scalar/string/damerau_levenshtein.cpp" +#include "extension/core_functions/scalar/string/printf.cpp" -#include "extension/core_functions/scalar/string/ascii.cpp" +#include "extension/core_functions/scalar/string/replace.cpp" -#include "extension/core_functions/scalar/string/starts_with.cpp" +#include "extension/core_functions/scalar/string/hamming.cpp" -#include "extension/core_functions/scalar/string/repeat.cpp" +#include "extension/core_functions/scalar/string/instr.cpp" -#include "extension/core_functions/scalar/string/chr.cpp" +#include "extension/core_functions/scalar/string/ascii.cpp" -#include "extension/core_functions/scalar/string/levenshtein.cpp" +#include "extension/core_functions/scalar/string/reverse.cpp" -#include "extension/core_functions/scalar/string/pad.cpp" +#include "extension/core_functions/scalar/string/url_encode.cpp" -#include "extension/core_functions/scalar/string/bar.cpp" +#include "extension/core_functions/scalar/string/parse_path.cpp" -#include "extension/core_functions/scalar/string/replace.cpp" +#include "extension/core_functions/scalar/string/left_right.cpp" #include "extension/core_functions/scalar/string/to_base.cpp" -#include "extension/core_functions/scalar/string/printf.cpp" +#include "extension/core_functions/scalar/string/pad.cpp" -#include "extension/core_functions/scalar/string/format_bytes.cpp" +#include "extension/core_functions/scalar/string/trim.cpp" -#include "extension/core_functions/scalar/string/instr.cpp" +#include "extension/core_functions/scalar/string/format_bytes.cpp" -#include "extension/core_functions/scalar/string/url_encode.cpp" +#include "extension/core_functions/scalar/string/hex.cpp" -#include "extension/core_functions/scalar/string/jaccard.cpp" +#include "extension/core_functions/scalar/string/repeat.cpp" -#include "extension/core_functions/scalar/string/reverse.cpp" +#include "extension/core_functions/scalar/string/translate.cpp" -#include "extension/core_functions/scalar/string/trim.cpp" +#include "extension/core_functions/scalar/string/chr.cpp" -#include "extension/core_functions/scalar/string/parse_path.cpp" +#include "extension/core_functions/scalar/string/unicode.cpp" #include "extension/core_functions/scalar/string/jaro_winkler.cpp" diff --git a/src/duckdb/ub_extension_core_functions_scalar_union.cpp b/src/duckdb/ub_extension_core_functions_scalar_union.cpp index c23d6ebff..fad24f297 100644 --- a/src/duckdb/ub_extension_core_functions_scalar_union.cpp +++ b/src/duckdb/ub_extension_core_functions_scalar_union.cpp @@ -1,6 +1,6 @@ -#include "extension/core_functions/scalar/union/union_value.cpp" - #include "extension/core_functions/scalar/union/union_extract.cpp" +#include "extension/core_functions/scalar/union/union_value.cpp" + #include "extension/core_functions/scalar/union/union_tag.cpp" diff --git a/src/duckdb/ub_src_function_table_system.cpp b/src/duckdb/ub_src_function_table_system.cpp index 95fcbe8fa..3204515dd 100644 --- a/src/duckdb/ub_src_function_table_system.cpp +++ b/src/duckdb/ub_src_function_table_system.cpp @@ -28,6 +28,8 @@ #include "src/function/table/system/duckdb_which_secret.cpp" +#include "src/function/table/system/duckdb_secret_types.cpp" + #include "src/function/table/system/duckdb_sequences.cpp" #include "src/function/table/system/duckdb_settings.cpp"